/*

* 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: CSocketsEngine implements an engine for connection 

* component checking: Interface opening/closing, connecting, 

* sending/receiving data, etc.

* CSocketsEngine is an active object

*

*/

#ifndef __SOCKETSENGINE_H__

#define __SOCKETSENGINE_H__

// INCLUDES

#include <in_sock.h>

#include <es_sock.h>

#include <http.h>

#include <commdbconnpref.h>

#include <extendedconnpref.h>

#include "TimeOutNotify.h"

#include "ProgressNotifyHandler.h"

#include "datasendnotifyhandler.h"

#include "conntest.hrh"

#include "alractiveobject.h"

// CONSTANTS

// FORWARD DECLARATIONS

class CSocketsRead;

class CSocketsWrite;

class CTimeOutTimer;

class MUINotify;

class CHttpClient;

class CProgressNotifier;

class CSettingData;

class CCustomPrefsData;

class CSendTimer;

// CLASS DECLARATION

/**

*  CSocketsEngine

*  

*  This class is the main engine part of the sockets application.

*  It establishes a TCP connection using its server name and port 

*  number (performing a DNS lookup operation first, if appropriate).

*  It creates instances of separate active objects to perform reading 

*  from, and writing to, the socket.

*/

class CSocketsEngine : public CActive, 

                       public MTimeOutNotify,

                       public MProgressNotifyHandler, 

                       public MDataSendNotifyHandler,

                       public MMobilityProtocolResp

{

public:

    enum TRoamingSetting

        {

        ERoamingOff,

        ERoamingAutomatic,

        ERoamingManual

        };

    // Utilized when selecting UI menu items

    enum TRoamingUIState

        {

        EIdle,

        EPendingPreferredCarrier,

        EPendingNewCarrierActive

        };

    enum TSocketsEngineState 

    {

        EInterfaceDown,

        EStartingInterface,

        EInterfaceUp,

        EConnecting,

        EConnected,

        EListening,

        ETimedOut, 

        ELookingUp,

        ELookUpFailed,

        EConnectFailed,

        EDisconnecting

    };

    enum TSocketsEngineStartType

    {

        EAskIap,

        EExtPrefs,

        EExtPrefsInternet,

        ENoPrefs,

        ENetworkId,

        ESnap,

        ETypeUnknown

    };

    /**

    * Two-phased constructor.

    * @param aConsole console to use for ui output

    * @return a pointer to the created instance of CSocketsEngine

    */

    static CSocketsEngine* NewL(MUINotify& aConsole);

    /**

    * Two-phased constructor.

    * @param aConsole console to use for ui output

    * @return a pointer to the created instance of CSocketsEngine

    */

    static CSocketsEngine* NewLC(MUINotify& aConsole);

    /**

    * Destructor.

    */

    ~CSocketsEngine();

    /**

     * Calls From ConnTestView that are responds to roaming notifications

     */

    void Migrate();

    void Ignore();

    void AcceptCarrier();

    void RejectCarrier();

    /**

    * Register to mobility API

    */

	void RegisterToMobilityAPIL();

    /**

    * UnRegister from mobility API

    */

	void UnRegisterFromMobilityAPI();

    /**

    * Start interface

    * @param aStartType Define start type (with or without preferences, by nework id)

    * @param aConnect   If True, make connection after startup

    */

    void StartInterfaceL(TSocketsEngineStartType aStartType, TBool aConnect = EFalse);

     /**

    * Start interface and possible connection with snap

    * @param aConnect   If True, make connection after startup

    */

    void StartConnWithSnapL(TBool aConnect = EFalse);

    /**

    * Starting method for testing RConnection::Close

    */

    void StartCloseInterfaceL();

    /**

    * Stop interface by calling RConnection::Stop

    */

    void StopInterfaceL();

    /**

    * Stop interface by calling RConnection::Close

    */

    void CloseInterface();

    /**

    * Make socket connection

    */

    void ConnectL();

    /**

    * Disconnect socket

    */

    void Disconnect();

    /**

    * Opens a Listening socket

    */

    void ListenL();

    /**

    * Write data to socket

    * @param aData data to be written

    */

    void WriteL(const TDesC8& aData);

    /**

    * Write data to socket (flood)

    * @param aData data to be written

    * @param aCount The data will be written aCount times

    */

    void WriteFloodL(const TDesC8& aData, TInt aCount);

    /**

    * Write HTTP request over socket

    * @param aHasBody defines if request has body

    */

	void SendHttpRequestOverSocketL(TBool aHasBody, TBool aDoPerformance);

    /**

    * Initiate read of data from socket

    */

    void Read();

    /**

    * Send HTTP request using http framework.

    * @param aHasBody       If true, send body data with POST

    * @param aDoPerformance If true, calculate performance, no outputs

    * @param aIsSecure      If true, make HTTPS request

    */

    void SendHttpFrameworkRequestL(TBool aHasBody, TBool aDoPerformance, TBool aIsSecure);

    /**

    * Print information about active connections and their

    * clients and sockets

    */

    void ConnectionInfoL();

    /**

    * Print information about interfaces.

    */

    void InterfaceInfoL();

    /**

    * Get socket engine state

    * @return Socket engine state

    */

    TSocketsEngineState GetSocketEngineState();

    /**

     * Gets Roaming state

     * @return TRoamingState

     */

    TRoamingUIState GetSocketEngineRoamingState();

    /**

     * Gets MobilityAPIImplementation

     * @return CALRActiveObject

     */

    CALRActiveObject* CSocketsEngine::GetMobilityAPI();

    /**

    * Get socket engine connection type

    * @return socket engine connection type

    */

    TSocketsEngineStartType GetSocketEngineConnType();

    /**

    * Set socket engine connection type

    */

    void SetSocketEngineConnType(const CSocketsEngine::TSocketsEngineStartType aConnStartType);

    /**

    * Set connection information

    * @param aData

    */

    void SetConnectionData(const CSettingData* aData);

    /**

    * Set Custom preferences data

    * @param aData

    */

    void SetCustomPrefsData(const CCustomPrefsData* aData);

    /**

    * QoS methods

    */

    void SetWLANQoS(TInt aClass);

    void QoS1();

    void QoS2();

    /**

    * Start the sending of the data

    * @param aData the data to send

    */

    void SendDataL(const TBuf8<KSendDataSize> aData);

    /**

    * Actual sending udp packets 

    * Must be public because of the timer calling it

    */

    void DoSendDataL();

public: // MDataSendNotifyHandler

    /**

    * The function to be called when data has been sent

    * @param aAmount the number of packets sent

    */

    void NotifySend(TInt aAmount);

public: // from MTimeOutNotify

    /**

    * The function to be called when a timeout occurs

    */

    void TimerExpired(); 

public: // from MProgressNotifyHandler

    /**

    * Handle progress notification

    */

    void ProgressNotifyReceivedL(TInt aStage, TInt aError);

    /**

    * Handle progress notification error

    */

    void ProgressNotifyError(TInt aStatus);

public: // from MMobilityProtocolResp

    /**

     * This method is called by middleware to notify that there are no suitable connections available.

     */

    virtual void Error( TInt aError ); 

    /**

     * This method is called by the middleware to notify a client about a new preferred connection.

     */

    virtual void PreferredCarrierAvailable(

                TAccessPointInfo aOldAP, 

                TAccessPointInfo aNewAP, 

                TBool aIsUpgrade, 

                TBool aIsSeamless ); 

    /**

     * This method is called by the middleware to notify a client that a preferred connection has been activated.

     */ 

    virtual void NewCarrierActive( TAccessPointInfo aNewAP, TBool aIsSeamless ); 

protected: // from CActive

    /**

    * Called when operation completes

    */

    void RunL();

    /**

    * Cancel any outstanding operation

    */

    void DoCancel();

private: // New methods

    /**

    * Perform the first phase of two phase construction 

    */

    CSocketsEngine(MUINotify& aConsole);

    /**

    * Perform the second phase construction of a CSocketsEngine 

    * @param aConsole the console to use for ui output

    */

    void ConstructL();

    /**

    * Initiate a connect operation on a socket

    * @param aAddr the ip address to connect to

    */

    void ConnectL(const TInetAddr& aAddr);

    /**

    * Handle a change in this object's status

    * @param aNewStatus new status

    */

    void ChangeStatus(TSocketsEngineState aNewStatus);

    /**

    * Display text on the console

    * @param aDes text to display

    */

    void PrintTextToConsole(const TDesC& aDes);

public: // for performance testing  

  	/**

	* Marks starting time into memory

	*

	*/

	void UDPFlood(TInt aPackets, TInt aPacketSize, TDesC& aData);

    /**

   	* Marks starting time into memory

    */

	void inline StartTickCount();

	/**

	* Calculates time interval using tick count and prints it

	*/

	void StopTickCount(const TDesC& aComponentName);

private:

	// Member variables

	TUint32						iStartTime; // for performance testing only

	TTime                       iStartTTime; // for performance testing only

	TTime						iThroughputStartTime; // for performance testing only

	TInt                        iTroughputDataSize;

    TCommDbConnPref             iPrefs;

    TConnPrefList*              iPrefsList;

    TExtendedConnPref*          iExtPrefs;

    CCustomPrefsData*           iCustomPrefsData;    

    RConnection                 iConnection;

    RConnection*                iCloseConnection;

    CProgressNotifier*          iProgressNotifier;

    CProgressNotifier*          iTempProgressNotifier;

    CHttpClient*                iHttpClient;

    TRoamingUIState             iRoamingState;

    TRoamingSetting             iRoaming;

	TSocketsEngineState         iEngineStatus; // this object's current status

	MUINotify&                  iConsole; // console for displaying text etc

	CSocketsRead*               iSocketsRead; // socket reader active object

	CSocketsWrite*              iSocketsWrite; // socket writer active object

	RSocket                     iSocket; // the actual socket

	RSocket						iListeningSocket;

	RSocketServ                 iSocketServ; // the socket server

	RHostResolver               iResolver; // DNS name resolver

	TNameEntry                  iNameEntry;

	TNameRecord                 iNameRecord;

	CTimeOutTimer*              iTimer; // timer active object

	TInetAddr                   iAddress;

    TInt                        iPort; // port number to connect to

    TBuf<KMaxServerNameLength>  iServerName; // server name to connect to

    TUint                       iProtocol;

    TUint                       iSocketType;

    TBool                       iConnectAfterStartup;

    TBuf<KMaxServerNameLength>  iHttpPage;

	CSettingData*               iSettingData;

    CSendTimer*                 iSendTimer; // timer active object

    HBufC8*                     iData; // The data to be sent

    TInt                        iSendCount;

    TBool                       iUseTTime;

    TBool 						iIsRegisteredToMobAPI; //flag to mark state of registration to Mob API

    CALRActiveObject*           iMobility; //pointer to mob API instance   

    TSocketsEngineStartType     iSockEngineStartType; //type of sock engine connection

    };

#endif // __SOCKETSENGINE_H__