C:/Projects/Software/Vss/Customer Archives/SmartFoxServer 2X/API Client/Cpp/trunk_api/SmartFox.h

// ===================================================================
//
// Description      
//      Contains the definition of SmartFox
//
// Revision history
//      Date            Description
//      30-Nov-2012     First version
//
// www.smartfoxserver.com
// (c) 2009-2016 gotoAndPlay()
// ===================================================================
#ifndef __SmartFox__
#define __SmartFox__

// Forward class declaration
namespace Sfs2X {
    class SmartFox;
}   // namespace Sfs2X

#if defined(_MSC_VER)
#pragma warning(disable:4786)           // STL library: disable warning 4786; this warning is generated due to a Microsoft bug
#endif
#include <vector>                       // STL library: vector object
#include <string>                       // STL library: string object
using namespace std;                    // STL library: declare the STL namespace

#include "Bitswarm/BitSwarmClient.h"
#include "Bitswarm/BitSwarmEvent.h"
#include "Util/EventDispatcher.h"
#include "Core/SFSIOHandler.h"
#include "Core/BaseEvent.h"
#include "Core/SFSEvent.h"
#include "Core/IDispatchable.h"
#include "Util/Common.h"
#include "Entities/Managers/IUserManager.h"
#include "Entities/Room.h"
#include "Entities/User.h"
#include "Entities/Managers/IBuddyManager.h"
#include "Entities/Managers/IRoomManager.h"
#include "Exceptions/SFSValidationError.h"
#include "FSM/FiniteStateMachine.h"
#include "Logging/Logger.h"
#include "Requests/IRequest.h"
#include "Util/ConfigData.h"
#include "Util/ConfigLoader.h"
#include "Util/LagMonitor.h"

#include <boost/exception/exception.hpp>
#include <boost/exception/all.hpp>
#include <boost/asio.hpp>                       // Boost Asio header
#include <boost/shared_ptr.hpp>                 // Boost Asio shared pointer
#include <boost/enable_shared_from_this.hpp>    // Boost shared_ptr for this

using namespace Sfs2X::Bitswarm;
using namespace Sfs2X::Util;
using namespace Sfs2X::Entities;
using namespace Sfs2X::Entities::Data;
using namespace Sfs2X::Requests;
using namespace Sfs2X::Core;
using namespace Sfs2X::Logging;
using namespace Sfs2X::Exceptions;
using namespace Sfs2X::Entities::Managers;

namespace Sfs2X {

    class DLLImportExport SmartFox : public IDispatchable, public boost::enable_shared_from_this<SmartFox>
    {
    public:

        // -------------------------------------------------------------------
        // Public methods
        // -------------------------------------------------------------------

        SmartFox();

        SmartFox(bool debug);

        virtual ~SmartFox();

        void Dispose();

        void SetClientDetails(boost::shared_ptr<string> platformId, boost::shared_ptr<string> version);

        boost::shared_ptr<BitSwarmClient> BitSwarm();
        boost::shared_ptr<Sfs2X::Logging::Logger> Log();

        void EnableLagMonitor(bool enabled, long int interval, long int queueSize);

        void EnableLagMonitor(bool enabled);

        void EnableLagMonitor(bool enabled, long int interval);

        bool IsConnecting();

        boost::shared_ptr<BitSwarmClient> GetSocketEngine();

        boost::shared_ptr<Sfs2X::Util::LagMonitor> LagMonitor();

        bool IsConnected();

        boost::shared_ptr<string> Version();

        boost::shared_ptr<string> HttpUploadURI();

        boost::shared_ptr<ConfigData> Config();

        bool UseBlueBox();
        void UseBlueBox(bool value);

        bool ForceIPv6();
        void ForceIPv6(bool value);

        boost::shared_ptr<string> ConnectionMode();

        long int CompressionThreshold();

        long int MaxMessageSize();

        boost::shared_ptr<Room> GetRoomById(long int id);

        boost::shared_ptr<Room> GetRoomByName(string name);

        boost::shared_ptr<vector<boost::shared_ptr<Room> > > GetRoomListFromGroup(string groupId);

        void KillConnection();

        void Connect(string host, long int port);

        void Connect();

        void Connect(string host);

        void Connect(boost::shared_ptr<ConfigData> cfg);

        void Disconnect();

        void ValidateConfig(boost::shared_ptr<ConfigData> cfg);

        boost::shared_ptr<string> GetIPAddress(string host, long int port);

        bool Debug();
        void Debug(bool value);

        boost::shared_ptr<string> CurrentIp();

        long int CurrentPort();

        boost::shared_ptr<string> CurrentZone();

        boost::shared_ptr<User> MySelf();
        void MySelf(boost::shared_ptr<User> value);

        boost::shared_ptr<Sfs2X::Logging::Logger> Logger();

        boost::shared_ptr<Room> LastJoinedRoom();
        void LastJoinedRoom(boost::shared_ptr<Room> value);

        boost::shared_ptr<vector<boost::shared_ptr<Room> > > JoinedRooms();

        boost::shared_ptr<vector<boost::shared_ptr<Room> > > RoomList();

        boost::shared_ptr<IRoomManager> RoomManager();

        boost::shared_ptr<IUserManager> UserManager();

        boost::shared_ptr<IBuddyManager> BuddyManager();

        bool UdpAvailable();

        bool UdpInited();

        void InitUDP();

        void InitUDP(string udpHost);

        void InitUDP(string udpHost, short int udpPort);

        bool IsJoining();
        void IsJoining(bool value);

        boost::shared_ptr<string> SessionToken();

        void DispatchEvent(boost::shared_ptr<BaseEvent> evt);

        bool ThreadSafeMode();
        void ThreadSafeMode(bool value);

        // No public docs for this, we use it internally for starting a reconnection
        long int GetReconnectionSeconds();
        
        // No public docs for this, we use it internally for starting a reconnection
        void SetReconnectionSeconds(long int seconds);

        void Send(boost::shared_ptr<IRequest> request);

        void LoadConfig(string filePath, bool connectOnSuccess);

        void LoadConfig(string filePath);

        void LoadConfig(bool connectOnSuccess);

        void LoadConfig();

        void AddLogListener(Sfs2X::Logging::LogLevel logLevel, boost::shared_ptr<EventListenerDelegate> eventListener);

        void AddJoinedRoom(boost::shared_ptr<Room> room);
        void RemoveJoinedRoom(boost::shared_ptr<Room> room);

        //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
        // Public handlers methods (used by SystemController)
        //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
        void HandleHandShake(boost::shared_ptr<BaseEvent> evt);

        void HandleLogin(boost::shared_ptr<BaseEvent> evt);

        void HandleClientDisconnection(boost::shared_ptr<string> reason);

        void HandleLogout();

        void HttpPort(unsigned short int httpPort);

        void ProcessEvents();

        // IDispatchable implementation

        void AddEventListener(boost::shared_ptr<string> eventType, boost::shared_ptr<EventListenerDelegate> listener);

        void RemoveEventListener (boost::shared_ptr<string> eventType, boost::shared_ptr<EventListenerDelegate> listener);

        void RemoveAllEventListeners();

        boost::shared_ptr<boost::asio::io_service> GetBoostService();

        void HandleReconnectionFailure();

        void InitCrypto();

        // -------------------------------------------------------------------
        // Public members
        // -------------------------------------------------------------------

    protected:

        // -------------------------------------------------------------------
        // Protected methods
        // -------------------------------------------------------------------

        // -------------------------------------------------------------------
        // Protected members
        // -------------------------------------------------------------------

    private:

        // -------------------------------------------------------------------
        // Private methods
        // -------------------------------------------------------------------

        void Initialize();
        void Reset();
        void DisconnectConnection(long int timeout);

        void HandleConnectionProblem(boost::shared_ptr<BaseEvent> e);
        void SendHandshakeRequest(bool isReconnection);
        void EnqueueEvent(boost::shared_ptr<BaseEvent> evt);
        void OnDisconnectConnectionEvent(const boost::system::error_code& code);
        void CleanEventParams(boost::shared_ptr<BaseEvent> e);

        boost::shared_ptr<EventDispatcher> Dispatcher();

        //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
        // Event handlers
        //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

        static void OnSocketConnect(unsigned long long context, boost::shared_ptr<BaseEvent> e);
        static void OnSocketClose(unsigned long long context, boost::shared_ptr<BaseEvent> e);
        static void OnSocketReconnectionTry(unsigned long long context, boost::shared_ptr<BaseEvent> e);
        static void OnSocketDataError(unsigned long long context, boost::shared_ptr<BaseEvent> e);
        static void OnSocketIOError(unsigned long long context, boost::shared_ptr<BaseEvent> e);
        static void OnSocketSecurityError(unsigned long long context, boost::shared_ptr<BaseEvent> e);
        static void OnConfigLoadSuccess(unsigned long long context, boost::shared_ptr<BaseEvent> e);
        static void OnConfigLoadFailure(unsigned long long context, boost::shared_ptr<BaseEvent> e);

        // -------------------------------------------------------------------
        // Private members
        // -------------------------------------------------------------------

        const static long int DEFAULT_HTTP_PORT = 8080;
        const static long int MAX_BB_CONNECT_ATTEMPTS = 3;
        const static char CLIENT_TYPE_SEPARATOR = ':';

        // Current version
        long int majVersion;
        long int minVersion;
        long int subVersion;

        boost::shared_ptr<BitSwarmClient> bitSwarm;

        // Stores the custom client details about the runtime platform
        boost::shared_ptr<string> clientDetails;

        boost::shared_ptr<Sfs2X::Util::LagMonitor> lagMonitor;

        // If true the client will fall back to BlueBox if no socket connection is available
        bool useBlueBox;

        // If true the client will use IPv6 for socket connection
        bool forceIPv6;

        // If true the client is in the middle of a join transaction
        bool isJoining;  
        
        // References the client's User object
        boost::shared_ptr<User> mySelf; 
        
        // A unique session token, sent by the server during the handshake
        boost::shared_ptr<string> sessionToken;
        
        // Last joined room
        boost::shared_ptr<Room> lastJoinedRoom;
        
        // The logger
        boost::shared_ptr<Sfs2X::Logging::Logger> log;
        
        // API initialization flag
        bool inited;
        
        // Protocol debug flag
        bool debug;
        
        // Thread safe mode. Once enabled, you have to run ProcessEvents manually to process the queued events in your thread.
        bool threadSafeMode;
        
        // Connection attempt flag
        bool isConnecting; 
        
        // The global user manager
        boost::shared_ptr<IUserManager> userManager; 
        
        // The global room manager
        boost::shared_ptr<IRoomManager> roomManager;
        
        // The global buddy manager
        boost::shared_ptr<IBuddyManager> buddyManager;
        
        boost::shared_ptr<ConfigData> config;
        
        // The name of the currently joined Zone
        boost::shared_ptr<string> currentZone;
        
        // When true -> starts the connection right after successful config loading
        bool autoConnectOnConfig;
        
        // Last ip address used for connection, used when falling back to BlueBox
        boost::shared_ptr<string> lastIpAddress;
        
        boost::shared_ptr<EventDispatcher> dispatcher;
        
        boost::shared_ptr<SynchronizationObject> eventsLocker;
        
        boost::shared_ptr<vector<boost::shared_ptr<BaseEvent> > > eventsQueue;
        
        long int bbConnectionAttempt;

        boost::shared_ptr<boost::asio::io_service> service;
        boost::shared_ptr<boost::asio::deadline_timer> disconnectTimer;         // Boost Asio deadline timer
    };

}   // namespace Sfs2X

#endif