websocket_interface.h

Go to the documentation of this file.

#ifndef YAZE_APP_NET_WEBSOCKET_INTERFACE_H_
#define YAZE_APP_NET_WEBSOCKET_INTERFACE_H_
 
#include <functional>
#include <string>
 
#include "absl/status/status.h"
 
namespace yaze {
namespace net {
 
enum class WebSocketState {
  kDisconnected,  // Not connected
  kConnecting,    // Connection in progress
  kConnected,     // Successfully connected
  kClosing,       // Close handshake in progress
  kClosed,        // Connection closed
  kError          // Error state
};
 
class IWebSocket {
 public:
  // Callback types for WebSocket events
  using MessageCallback = std::function<void(const std::string& message)>;
  using BinaryMessageCallback = std::function<void(const uint8_t* data, size_t length)>;
  using OpenCallback = std::function<void()>;
  using CloseCallback = std::function<void(int code, const std::string& reason)>;
  using ErrorCallback = std::function<void(const std::string& error)>;
 
  virtual ~IWebSocket() = default;
 
  virtual absl::Status Connect(const std::string& url) = 0;
 
  virtual absl::Status Send(const std::string& message) = 0;
 
  virtual absl::Status SendBinary(const uint8_t* data, size_t length) {
    // Default implementation - can be overridden if binary is supported
    return absl::UnimplementedError("Binary messages not implemented");
  }
 
  virtual absl::Status Close(int code = 1000,
                            const std::string& reason = "") = 0;
 
  virtual WebSocketState GetState() const = 0;
 
  virtual bool IsConnected() const {
    return GetState() == WebSocketState::kConnected;
  }
 
  virtual void OnMessage(MessageCallback callback) = 0;
 
  virtual void OnBinaryMessage(BinaryMessageCallback callback) {
    // Default implementation - can be overridden if binary is supported
    binary_message_callback_ = callback;
  }
 
  virtual void OnOpen(OpenCallback callback) = 0;
 
  virtual void OnClose(CloseCallback callback) = 0;
 
  virtual void OnError(ErrorCallback callback) = 0;
 
  virtual std::string GetUrl() const { return url_; }
 
  virtual void SetAutoReconnect(bool enable, int delay_seconds = 5) {
    auto_reconnect_ = enable;
    reconnect_delay_seconds_ = delay_seconds;
  }
 
 protected:
  std::string url_;
  WebSocketState state_ = WebSocketState::kDisconnected;
 
  // Callbacks (may be used by implementations)
  MessageCallback message_callback_;
  BinaryMessageCallback binary_message_callback_;
  OpenCallback open_callback_;
  CloseCallback close_callback_;
  ErrorCallback error_callback_;
 
  // Auto-reconnect settings
  bool auto_reconnect_ = false;
  int reconnect_delay_seconds_ = 5;
};
 
}  // namespace net
}  // namespace yaze
 
#endif  // YAZE_APP_NET_WEBSOCKET_INTERFACE_H_