forked from me-no-dev/ESPAsyncWebServer
Removed AsyncWebSocketBuffer
This commit is contained in:
File diff suppressed because it is too large
Load Diff
@@ -84,137 +84,25 @@ typedef enum { WS_CONTINUATION, WS_TEXT, WS_BINARY, WS_DISCONNECT = 0x08, WS_PIN
|
||||
typedef enum { WS_MSG_SENDING, WS_MSG_SENT, WS_MSG_ERROR } AwsMessageStatus;
|
||||
typedef enum { WS_EVT_CONNECT, WS_EVT_DISCONNECT, WS_EVT_PONG, WS_EVT_ERROR, WS_EVT_DATA } AwsEventType;
|
||||
|
||||
class AsyncWebSocketMessageBuffer {
|
||||
class AsyncWebSocketMessage
|
||||
{
|
||||
private:
|
||||
std::unique_ptr<uint8_t[]> _data;
|
||||
//uint8_t * _data;
|
||||
size_t _len{};
|
||||
//bool _lock;
|
||||
//uint32_t _count;
|
||||
std::shared_ptr<std::vector<uint8_t>> _WSbuffer;
|
||||
uint8_t _opcode{WS_TEXT};
|
||||
bool _mask{false};
|
||||
AwsMessageStatus _status{WS_MSG_ERROR};
|
||||
size_t _sent{};
|
||||
size_t _ack{};
|
||||
size_t _acked{};
|
||||
|
||||
public:
|
||||
AsyncWebSocketMessageBuffer();
|
||||
AsyncWebSocketMessageBuffer(size_t size);
|
||||
AsyncWebSocketMessageBuffer(uint8_t *data, size_t size);
|
||||
//AsyncWebSocketMessageBuffer(const AsyncWebSocketMessageBuffer &);
|
||||
//AsyncWebSocketMessageBuffer(AsyncWebSocketMessageBuffer &&);
|
||||
~AsyncWebSocketMessageBuffer();
|
||||
//void operator ++(int i) { Serial.printf("AsyncWebSocketMessageBuffer::operator++() this=0x%llx\r\n", uint64_t(this)); (void)i; _count++; }
|
||||
//void operator --(int i) { Serial.printf("AsyncWebSocketMessageBuffer::operator--() this=0x%llx\r\n", uint64_t(this)); (void)i; if (_count > 0) { _count--; } ; }
|
||||
bool reserve(size_t size);
|
||||
//void lock() { Serial.printf("AsyncWebSocketMessageBuffer::lock() this=0x%llx\r\n", uint64_t(this)); _lock = true; }
|
||||
//void unlock() { Serial.printf("AsyncWebSocketMessageBuffer::unlock() this=0x%llx\r\n", uint64_t(this)); _lock = false; }
|
||||
uint8_t *get() { Serial.printf("AsyncWebSocketMessageBuffer::get() this=0x%llx\r\n", uint64_t(this)); return _data.get(); }
|
||||
size_t length() { Serial.printf("AsyncWebSocketMessageBuffer::length() this=0x%llx\r\n", uint64_t(this)); return _len; }
|
||||
//uint32_t count() { Serial.printf("AsyncWebSocketMessageBuffer::count() this=0x%llx\r\n", uint64_t(this)); return _count; }
|
||||
//bool canDelete() { Serial.printf("AsyncWebSocketMessageBuffer::canDelete() this=0x%llx\r\n", uint64_t(this)); return (!_count && !_lock); }
|
||||
AsyncWebSocketMessage(std::shared_ptr<std::vector<uint8_t>> buffer, uint8_t opcode=WS_TEXT, bool mask=false);
|
||||
|
||||
//friend AsyncWebSocket;
|
||||
bool finished() const { return _status != WS_MSG_SENDING; }
|
||||
bool betweenFrames() const { return _acked == _ack; }
|
||||
|
||||
};
|
||||
|
||||
class AsyncWebSocketMessage {
|
||||
protected:
|
||||
uint8_t _opcode;
|
||||
bool _mask;
|
||||
AwsMessageStatus _status;
|
||||
public:
|
||||
AsyncWebSocketMessage():_opcode(WS_TEXT),_mask(false),_status(WS_MSG_ERROR){}
|
||||
virtual ~AsyncWebSocketMessage(){}
|
||||
virtual void ack(size_t len __attribute__((unused)), uint32_t time __attribute__((unused))){}
|
||||
virtual size_t send(AsyncClient *client __attribute__((unused))){ return 0; }
|
||||
virtual bool finished(){ return _status != WS_MSG_SENDING; }
|
||||
virtual bool betweenFrames() const { return false; }
|
||||
};
|
||||
|
||||
class AsyncWebSocketBasicMessage: public AsyncWebSocketMessage {
|
||||
private:
|
||||
size_t _len;
|
||||
size_t _sent;
|
||||
size_t _ack;
|
||||
size_t _acked;
|
||||
uint8_t * _data;
|
||||
public:
|
||||
AsyncWebSocketBasicMessage(const char * data, size_t len, uint8_t opcode=WS_TEXT, bool mask=false);
|
||||
AsyncWebSocketBasicMessage(uint8_t opcode=WS_TEXT, bool mask=false);
|
||||
virtual ~AsyncWebSocketBasicMessage() override;
|
||||
virtual bool betweenFrames() const override { return _acked == _ack; }
|
||||
virtual void ack(size_t len, uint32_t time) override ;
|
||||
virtual size_t send(AsyncClient *client) override ;
|
||||
};
|
||||
|
||||
class AsyncWebSocketMultiMessage: public AsyncWebSocketMessage {
|
||||
private:
|
||||
uint8_t * _data;
|
||||
size_t _len;
|
||||
size_t _sent;
|
||||
size_t _ack;
|
||||
size_t _acked;
|
||||
std::shared_ptr<AsyncWebSocketMessageBuffer> _WSbuffer;
|
||||
|
||||
public:
|
||||
AsyncWebSocketMultiMessage(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer, uint8_t opcode=WS_TEXT, bool mask=false);
|
||||
virtual ~AsyncWebSocketMultiMessage() override;
|
||||
virtual bool betweenFrames() const override { return _acked == _ack; }
|
||||
virtual void ack(size_t len, uint32_t time) override ;
|
||||
virtual size_t send(AsyncClient *client) override ;
|
||||
};
|
||||
|
||||
class PolymorphMessageContainer
|
||||
{
|
||||
union {
|
||||
AsyncWebSocketBasicMessage basicMessage;
|
||||
AsyncWebSocketMultiMessage multiMessage;
|
||||
};
|
||||
|
||||
enum class Type : uint8_t { Basic, Multi };
|
||||
const Type type;
|
||||
|
||||
public:
|
||||
PolymorphMessageContainer() = delete;
|
||||
PolymorphMessageContainer(const PolymorphMessageContainer &) = delete;
|
||||
PolymorphMessageContainer &operator=(const PolymorphMessageContainer &) = delete;
|
||||
|
||||
PolymorphMessageContainer(const char *data, size_t len, uint8_t opcode=WS_TEXT, bool mask=false) :
|
||||
type{Type::Basic}
|
||||
{
|
||||
new (&basicMessage) AsyncWebSocketBasicMessage{data, len, opcode, mask};
|
||||
}
|
||||
|
||||
PolymorphMessageContainer(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer, uint8_t opcode=WS_TEXT, bool mask=false) :
|
||||
type{Type::Multi}
|
||||
{
|
||||
new (&multiMessage) AsyncWebSocketMultiMessage{buffer, opcode, mask};
|
||||
}
|
||||
|
||||
~PolymorphMessageContainer()
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case Type::Basic: basicMessage.~AsyncWebSocketBasicMessage(); break;
|
||||
case Type::Multi: multiMessage.~AsyncWebSocketMultiMessage(); break;
|
||||
}
|
||||
}
|
||||
|
||||
AsyncWebSocketMessage &get()
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case Type::Basic: return basicMessage;
|
||||
case Type::Multi: return multiMessage;
|
||||
}
|
||||
__builtin_unreachable();
|
||||
}
|
||||
|
||||
const AsyncWebSocketMessage &get() const
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case Type::Basic: return basicMessage;
|
||||
case Type::Multi: return multiMessage;
|
||||
}
|
||||
__builtin_unreachable();
|
||||
}
|
||||
void ack(size_t len, uint32_t time);
|
||||
size_t send(AsyncClient *client);
|
||||
};
|
||||
|
||||
class AsyncWebSocketClient {
|
||||
@@ -227,7 +115,7 @@ class AsyncWebSocketClient {
|
||||
AsyncWebLock _lock;
|
||||
|
||||
std::queue<AsyncWebSocketControl> _controlQueue;
|
||||
std::queue<PolymorphMessageContainer> _messageQueue;
|
||||
std::queue<AsyncWebSocketMessage> _messageQueue;
|
||||
|
||||
uint8_t _pstate;
|
||||
AwsFrameInfo _pinfo;
|
||||
@@ -235,9 +123,8 @@ class AsyncWebSocketClient {
|
||||
uint32_t _lastMessageTime;
|
||||
uint32_t _keepAlivePeriod;
|
||||
|
||||
void _queueControl(uint8_t opcode, uint8_t *data=NULL, size_t len=0, bool mask=false);
|
||||
void _queueMessage(const char *data, size_t len, uint8_t opcode=WS_TEXT, bool mask=false);
|
||||
void _queueMessage(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer, uint8_t opcode=WS_TEXT, bool mask=false);
|
||||
void _queueControl(uint8_t opcode, const uint8_t *data=NULL, size_t len=0, bool mask=false);
|
||||
void _queueMessage(std::shared_ptr<std::vector<uint8_t>> buffer, uint8_t opcode=WS_TEXT, bool mask=false);
|
||||
void _runQueue();
|
||||
|
||||
public:
|
||||
@@ -260,7 +147,7 @@ class AsyncWebSocketClient {
|
||||
|
||||
//control frames
|
||||
void close(uint16_t code=0, const char * message=NULL);
|
||||
void ping(uint8_t *data=NULL, size_t len=0);
|
||||
void ping(const uint8_t *data=NULL, size_t len=0);
|
||||
|
||||
//set auto-ping period in seconds. disabled if zero (default)
|
||||
void keepAlivePeriod(uint16_t seconds){
|
||||
@@ -271,29 +158,27 @@ class AsyncWebSocketClient {
|
||||
}
|
||||
|
||||
//data packets
|
||||
void message(const char *data, size_t len, uint8_t opcode=WS_TEXT, bool mask=false) { _queueMessage(data, len, opcode, mask); }
|
||||
void message(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer, uint8_t opcode=WS_TEXT, bool mask=false) { _queueMessage(buffer, opcode, mask); }
|
||||
void message(std::shared_ptr<std::vector<uint8_t>> buffer, uint8_t opcode=WS_TEXT, bool mask=false) { _queueMessage(buffer, opcode, mask); }
|
||||
bool queueIsFull() const;
|
||||
|
||||
size_t printf(const char *format, ...) __attribute__ ((format (printf, 2, 3)));
|
||||
#ifndef ESP32
|
||||
size_t printf_P(PGM_P formatP, ...) __attribute__ ((format (printf, 2, 3)));
|
||||
#endif
|
||||
|
||||
void text(std::shared_ptr<std::vector<uint8_t>> buffer);
|
||||
void text(const uint8_t *message, size_t len);
|
||||
void text(const char *message, size_t len);
|
||||
void text(const char *message);
|
||||
void text(uint8_t * message, size_t len);
|
||||
void text(char * message);
|
||||
void text(const String &message);
|
||||
void text(const __FlashStringHelper *data);
|
||||
void text(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer);
|
||||
void text(const __FlashStringHelper *message);
|
||||
|
||||
void binary(std::shared_ptr<std::vector<uint8_t>> buffer);
|
||||
void binary(const uint8_t *message, size_t len);
|
||||
void binary(const char *message, size_t len);
|
||||
void binary(const char *message);
|
||||
void binary(uint8_t * message, size_t len);
|
||||
void binary(char * message);
|
||||
void binary(const String &message);
|
||||
void binary(const __FlashStringHelper *data, size_t len);
|
||||
void binary(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer);
|
||||
void binary(const __FlashStringHelper *message, size_t len);
|
||||
|
||||
bool canSend() const;
|
||||
|
||||
@@ -335,42 +220,34 @@ class AsyncWebSocket: public AsyncWebHandler {
|
||||
void closeAll(uint16_t code=0, const char * message=NULL);
|
||||
void cleanupClients(uint16_t maxClients = DEFAULT_MAX_WS_CLIENTS);
|
||||
|
||||
void ping(uint32_t id, uint8_t *data=NULL, size_t len=0);
|
||||
void pingAll(uint8_t *data=NULL, size_t len=0); // done
|
||||
void ping(uint32_t id, const uint8_t *data=NULL, size_t len=0);
|
||||
void pingAll(const uint8_t *data=NULL, size_t len=0); // done
|
||||
|
||||
void text(uint32_t id, const uint8_t *message, size_t len);
|
||||
void text(uint32_t id, const char *message, size_t len);
|
||||
void text(uint32_t id, const char *message);
|
||||
void text(uint32_t id, uint8_t * message, size_t len);
|
||||
void text(uint32_t id, char * message);
|
||||
void text(uint32_t id, const String &message);
|
||||
void text(uint32_t id, const __FlashStringHelper *message);
|
||||
|
||||
void textAll(std::shared_ptr<std::vector<uint8_t>> buffer);
|
||||
void textAll(const uint8_t *message, size_t len);
|
||||
void textAll(const char * message, size_t len);
|
||||
void textAll(const char * message);
|
||||
void textAll(uint8_t * message, size_t len);
|
||||
void textAll(char * message);
|
||||
void textAll(const String &message);
|
||||
void textAll(const __FlashStringHelper *message); // need to convert
|
||||
void textAll(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer);
|
||||
|
||||
void binary(uint32_t id, const uint8_t *message, size_t len);
|
||||
void binary(uint32_t id, const char *message, size_t len);
|
||||
void binary(uint32_t id, const char *message);
|
||||
void binary(uint32_t id, uint8_t * message, size_t len);
|
||||
void binary(uint32_t id, char * message);
|
||||
void binary(uint32_t id, const String &message);
|
||||
void binary(uint32_t id, const __FlashStringHelper *message, size_t len);
|
||||
|
||||
void binaryAll(std::shared_ptr<std::vector<uint8_t>> buffer);
|
||||
void binaryAll(const uint8_t *message, size_t len);
|
||||
void binaryAll(const char *message, size_t len);
|
||||
void binaryAll(const char *message);
|
||||
void binaryAll(uint8_t * message, size_t len);
|
||||
void binaryAll(char * message);
|
||||
void binaryAll(const String &message);
|
||||
void binaryAll(const __FlashStringHelper *message, size_t len);
|
||||
void binaryAll(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer);
|
||||
|
||||
void message(uint32_t id, const char *data, size_t len, uint8_t opcode=WS_TEXT, bool mask=false);
|
||||
void message(uint32_t id, std::shared_ptr<AsyncWebSocketMessageBuffer> buffer, uint8_t opcode=WS_TEXT, bool mask=false);
|
||||
void messageAll(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer, uint8_t opcode=WS_TEXT, bool mask=false);
|
||||
|
||||
size_t printf(uint32_t id, const char *format, ...) __attribute__ ((format (printf, 3, 4)));
|
||||
size_t printfAll(const char *format, ...) __attribute__ ((format (printf, 2, 3)));
|
||||
@@ -393,13 +270,6 @@ class AsyncWebSocket: public AsyncWebHandler {
|
||||
virtual bool canHandle(AsyncWebServerRequest *request) override final;
|
||||
virtual void handleRequest(AsyncWebServerRequest *request) override final;
|
||||
|
||||
|
||||
// messagebuffer functions/objects.
|
||||
std::shared_ptr<AsyncWebSocketMessageBuffer> makeBuffer(size_t size = 0);
|
||||
std::shared_ptr<AsyncWebSocketMessageBuffer> makeBuffer(uint8_t * data, size_t size);
|
||||
std::list<std::weak_ptr<AsyncWebSocketMessageBuffer>> _buffers;
|
||||
void _cleanBuffers();
|
||||
|
||||
const auto &getClients() const { return _clients; }
|
||||
};
|
||||
|
||||
|
||||
Reference in New Issue
Block a user