feedc0de/AsyncHTTPRequest_Generic
1
0
Fork 0
forked from khoih-prog/AsyncHTTPRequest_Generic
Code Pull Requests Activity

Generel conversion to c++

Browse Source
This commit is contained in:
0xFEEDC0DE64
2020-10-09 14:23:40 +02:00
parent a614f53ac6
commit 9cd3c2c56e
2 changed files with 77 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
src/AsyncHTTPRequest.cpp
View File

@ -1,5 +1,5 @@
/****************************************************************************************************************************
AsyncHTTPRequest_Impl_Generic.h - Dead simple AsyncHTTPRequest for ESP8266, ESP32 and currently STM32 with built-in LAN8742A Ethernet
AsyncHTTPRequest.cpp - Dead simple AsyncHTTPRequest for ESP8266, ESP32 and currently STM32 with built-in LAN8742A Ethernet
For ESP8266, ESP32 and STM32 with built-in LAN8742A Ethernet (Nucleo-144, DISCOVERY, etc)
@ -24,10 +24,10 @@
1.0.0 K Hoang 14/09/2020 Initial coding to add support to STM32 using built-in Ethernet (Nucleo-144, DISCOVERY, etc).
*****************************************************************************************************************************/
#include "AsyncHTTPRequest_Generic.h"
#include "AsyncHTTPRequest.h"
//**************************************************************************************************************
AsyncHTTPRequest::AsyncHTTPRequest(): _readyState(readyStateUnsent), _HTTPcode(0), _chunked(false), _debug(DEBUG_IOTA_HTTP_SET)
AsyncHTTPRequest::AsyncHTTPRequest(): _readyState(ReadyState::Unsent), _HTTPcode(0), _chunked(false), _debug(DEBUG_IOTA_HTTP_SET)
, _timeout(DEFAULT_RX_TIMEOUT), _lastActivity(0), _requestStartTime(0), _requestEndTime(0), _URL(nullptr)
, _connectedHost(nullptr), _connectedPort(-1), _client(nullptr), _contentLength(0), _contentRead(0)
, _readyStateChangeCB(nullptr), _readyStateChangeCBarg(nullptr), _onDataCB(nullptr), _onDataCBarg(nullptr)
@ -69,9 +69,9 @@ void AsyncHTTPRequest::setDebug(bool debug)
}
//**************************************************************************************************************
bool AsyncHTTPRequest::debug()
bool AsyncHTTPRequest::debug() const
{
return (_debug);
return _debug;
}
//**************************************************************************************************************
@ -79,7 +79,7 @@ bool AsyncHTTPRequest::open(const char* method, const char* URL)
{
AHTTP_LOGDEBUG3("open(", method, ", url =", URL);
if (_readyState != readyStateUnsent && _readyState != readyStateDone)
if (_readyState != ReadyState::Unsent && _readyState != ReadyState::Done)
{
return false;
}
@ -99,7 +99,7 @@ bool AsyncHTTPRequest::open(const char* method, const char* URL)
_chunks = nullptr;
_chunked = false;
_contentRead = 0;
_readyState = readyStateUnsent;
_readyState = ReadyState::Unsent;
if (strcmp(method, "GET") == 0)
{
@ -130,12 +130,18 @@ bool AsyncHTTPRequest::open(const char* method, const char* URL)
return _connect();
}
//**************************************************************************************************************
void AsyncHTTPRequest::onReadyStateChange(readyStateChangeCB cb, void* arg)
void AsyncHTTPRequest::onReadyStateChange(readyStateChangeCB cb, void* arg)
{
_readyStateChangeCB = cb;
_readyStateChangeCBarg = arg;
}
//**************************************************************************************************************
void AsyncHTTPRequest::onReadyStateChangeArg(void* arg)
{
_readyStateChangeCBarg = arg;
}
//**************************************************************************************************************
void AsyncHTTPRequest::setTimeout(int seconds)
{
@ -261,13 +267,13 @@ void AsyncHTTPRequest::abort()
_unlock;
}
//**************************************************************************************************************
reqStates AsyncHTTPRequest::readyState()
ReadyState AsyncHTTPRequest::readyState() const
{
return _readyState;
}
//**************************************************************************************************************
int AsyncHTTPRequest::responseHTTPcode()
int AsyncHTTPRequest::responseHTTPcode() const
{
return _HTTPcode;
}
@ -279,7 +285,7 @@ String AsyncHTTPRequest::responseText()
_lock;
if ( ! _response || _readyState < readyStateLoading || ! available())
if ( ! _response || _readyState < ReadyState::Loading || ! available())
{
AHTTP_LOGDEBUG("responseText() no data");
@ -315,7 +321,7 @@ String AsyncHTTPRequest::responseText()
//**************************************************************************************************************
size_t AsyncHTTPRequest::responseRead(uint8_t* buf, size_t len)
{
if ( ! _response || _readyState < readyStateLoading || ! available())
if ( ! _response || _readyState < ReadyState::Loading || ! available())
{
//DEBUG_HTTP("responseRead() no data\r\n");
AHTTP_LOGDEBUG("responseRead() no data");
@ -336,9 +342,9 @@ size_t AsyncHTTPRequest::responseRead(uint8_t* buf, size_t len)
}
//**************************************************************************************************************
size_t AsyncHTTPRequest::available()
size_t AsyncHTTPRequest::available() const
{
if (_readyState < readyStateLoading)
if (_readyState < ReadyState::Loading)
return 0;
if (_chunked && (_contentLength - _contentRead) < _response->available())
@ -350,9 +356,9 @@ size_t AsyncHTTPRequest::available()
}
//**************************************************************************************************************
size_t AsyncHTTPRequest::responseLength()
size_t AsyncHTTPRequest::responseLength() const
{
if (_readyState < readyStateLoading)
if (_readyState < ReadyState::Loading)
return 0;
return _contentLength;
@ -368,12 +374,12 @@ void AsyncHTTPRequest::onData(onDataCB cb, void* arg)
}
//**************************************************************************************************************
uint32_t AsyncHTTPRequest::elapsedTime()
uint32_t AsyncHTTPRequest::elapsedTime() const
{
if (_readyState <= readyStateOpened)
if (_readyState <= ReadyState::Opened)
return 0;
if (_readyState != readyStateDone)
if (_readyState != ReadyState::Done)
{
return millis() - _requestStartTime;
}
@ -382,7 +388,7 @@ uint32_t AsyncHTTPRequest::elapsedTime()
}
//**************************************************************************************************************
String AsyncHTTPRequest::version()
String AsyncHTTPRequest::version() const
{
return String(AsyncHTTPRequest_Generic_version);
}
@ -497,7 +503,7 @@ bool AsyncHTTPRequest::_connect()
AHTTP_LOGDEBUG3("client.connect failed:", _URL->host, ",", _URL->port);
_HTTPcode = HTTPCODE_NOT_CONNECTED;
_setReadyState(readyStateDone);
_setReadyState(ReadyState::Done);
return false;
}
@ -596,13 +602,13 @@ size_t AsyncHTTPRequest::_send()
}
//**************************************************************************************************************
void AsyncHTTPRequest::_setReadyState(reqStates newState)
void AsyncHTTPRequest::_setReadyState(ReadyState readyState)
{
if (_readyState != newState)
if (_readyState != readyState)
{
_readyState = newState;
_readyState = readyState;
AHTTP_LOGDEBUG1("_setReadyState :", _readyState);
AHTTP_LOGDEBUG1("_setReadyState :", int(_readyState));
if (_readyStateChangeCB)
{
@ -651,7 +657,7 @@ void AsyncHTTPRequest::_processChunks()
_requestEndTime = millis();
_lastActivity = 0;
_timeout = 0;
_setReadyState(readyStateDone);
_setReadyState(ReadyState::Done);
return;
}
@ -674,7 +680,7 @@ void AsyncHTTPRequest::_onConnect(AsyncClient* client)
_lock;
_client = client;
_setReadyState(readyStateOpened);
_setReadyState(ReadyState::Opened);
_response = new xbuf;
_contentLength = 0;
_contentRead = 0;
@ -735,12 +741,12 @@ void AsyncHTTPRequest::_onDisconnect(AsyncClient* client)
_lock;
if (_readyState < readyStateOpened)
if (_readyState < ReadyState::Opened)
{
_HTTPcode = HTTPCODE_NOT_CONNECTED;
}
else if (_HTTPcode > 0 &&
(_readyState < readyStateHdrsRecvd || (_contentRead + _response->available()) < _contentLength))
(_readyState < ReadyState::HdrsRecvd || (_contentRead + _response->available()) < _contentLength))
{
_HTTPcode = HTTPCODE_CONNECTION_LOST;
}
@ -754,7 +760,7 @@ void AsyncHTTPRequest::_onDisconnect(AsyncClient* client)
_connectedPort = -1;
_requestEndTime = millis();
_lastActivity = 0;
_setReadyState(readyStateDone);
_setReadyState(ReadyState::Done);
_unlock;
}
@ -777,16 +783,16 @@ void AsyncHTTPRequest::_onData(void* Vbuf, size_t len)
}
// if headers not complete, collect them. If still not complete, just return.
if (_readyState == readyStateOpened)
if (_readyState == ReadyState::Opened)
{
if ( ! _collectHeaders())
return;
}
// If there's data in the buffer and not Done, advance readyState to Loading.
if (_response->available() && _readyState != readyStateDone)
if (_response->available() && _readyState != ReadyState::Done)
{
_setReadyState(readyStateLoading);
_setReadyState(ReadyState::Loading);
}
// If not chunked and all data read, close it up.
@ -808,7 +814,7 @@ void AsyncHTTPRequest::_onData(void* Vbuf, size_t len)
_requestEndTime = millis();
_lastActivity = 0;
_timeout = 0;
_setReadyState(readyStateDone);
_setReadyState(ReadyState::Done);
}
// If onData callback requested, do so.
@ -840,7 +846,7 @@ bool AsyncHTTPRequest::_collectHeaders()
// If empty line, all headers are in, advance readyState.
if (headerLine.length() == 2)
{
_setReadyState(readyStateHdrsRecvd);
_setReadyState(ReadyState::HdrsRecvd);
}
// If line is HTTP header, capture HTTPcode.
else if (headerLine.substring(0, 7) == "HTTP/1.")
@ -861,7 +867,7 @@ bool AsyncHTTPRequest::_collectHeaders()
_addHeader(name.c_str(), value.c_str());
}
}
} while (_readyState == readyStateOpened);
} while (_readyState == ReadyState::Opened);
// If content-Length header, set _contentLength
header *hdr = _getHeader("Content-Length");
@ -901,7 +907,7 @@ bool AsyncHTTPRequest::_collectHeaders()
//**************************************************************************************************************
void AsyncHTTPRequest::setReqHeader(const char* name, const char* value)
{
if (_readyState <= readyStateOpened && _headers)
if (_readyState <= ReadyState::Opened && _headers)
{
_addHeader(name, value);
}
@ -910,7 +916,7 @@ void AsyncHTTPRequest::setReqHeader(const char* name, const char* value)
//**************************************************************************************************************
void AsyncHTTPRequest::setReqHeader(const char* name, int32_t value)
{
if (_readyState <= readyStateOpened && _headers)
if (_readyState <= ReadyState::Opened && _headers)
{
setReqHeader(name, String(value).c_str());
}
@ -921,7 +927,7 @@ void AsyncHTTPRequest::setReqHeader(const char* name, int32_t value)
//**************************************************************************************************************
void AsyncHTTPRequest::setReqHeader(const char* name, const __FlashStringHelper* value)
{
if (_readyState <= readyStateOpened && _headers)
if (_readyState <= ReadyState::Opened && _headers)
{
char* _value = _charstar(value);
_addHeader(name, _value);
@ -932,7 +938,7 @@ void AsyncHTTPRequest::setReqHeader(const char* name, const __FlashStringHelper*
//**************************************************************************************************************
void AsyncHTTPRequest::setReqHeader(const __FlashStringHelper *name, const char* value)
{
if (_readyState <= readyStateOpened && _headers)
if (_readyState <= ReadyState::Opened && _headers)
{
char* _name = _charstar(name);
_addHeader(_name, value);
@ -943,7 +949,7 @@ void AsyncHTTPRequest::setReqHeader(const __FlashStringHelper *name, const char*
//**************************************************************************************************************
void AsyncHTTPRequest::setReqHeader(const __FlashStringHelper *name, const __FlashStringHelper* value)
{
if (_readyState <= readyStateOpened && _headers)
if (_readyState <= ReadyState::Opened && _headers)
{
char* _name = _charstar(name);
char* _value = _charstar(value);
@ -956,7 +962,7 @@ void AsyncHTTPRequest::setReqHeader(const __FlashStringHelper *name, const __Fla
//**************************************************************************************************************
void AsyncHTTPRequest::setReqHeader(const __FlashStringHelper *name, int32_t value)
{
if (_readyState <= readyStateOpened && _headers)
if (_readyState <= ReadyState::Opened && _headers)
{
char* _name = _charstar(name);
setReqHeader(_name, String(value).c_str());
@ -969,7 +975,7 @@ void AsyncHTTPRequest::setReqHeader(const __FlashStringHelper *name, int32_t val
//**************************************************************************************************************
int AsyncHTTPRequest::respHeaderCount()
{
if (_readyState < readyStateHdrsRecvd)
if (_readyState < ReadyState::HdrsRecvd)
return 0;
int count = 0;
@ -987,7 +993,7 @@ int AsyncHTTPRequest::respHeaderCount()
//**************************************************************************************************************
char* AsyncHTTPRequest::respHeaderName(int ndx)
{
if (_readyState < readyStateHdrsRecvd)
if (_readyState < ReadyState::HdrsRecvd)
return nullptr;
header* hdr = _getHeader(ndx);
@ -1001,7 +1007,7 @@ char* AsyncHTTPRequest::respHeaderName(int ndx)
//**************************************************************************************************************
char* AsyncHTTPRequest::respHeaderValue(const char* name)
{
if (_readyState < readyStateHdrsRecvd)
if (_readyState < ReadyState::HdrsRecvd)
return nullptr;
header* hdr = _getHeader(name);
@ -1015,7 +1021,7 @@ char* AsyncHTTPRequest::respHeaderValue(const char* name)
//**************************************************************************************************************
char* AsyncHTTPRequest::respHeaderValue(int ndx)
{
if (_readyState < readyStateHdrsRecvd)
if (_readyState < ReadyState::HdrsRecvd)
return nullptr;
header* hdr = _getHeader(ndx);
@ -1029,7 +1035,7 @@ char* AsyncHTTPRequest::respHeaderValue(int ndx)
//**************************************************************************************************************
bool AsyncHTTPRequest::respHeaderExists(const char* name)
{
if (_readyState < readyStateHdrsRecvd)
if (_readyState < ReadyState::HdrsRecvd)
return false;
header* hdr = _getHeader(name);
@ -1046,7 +1052,7 @@ bool AsyncHTTPRequest::respHeaderExists(const char* name)
//**************************************************************************************************************
char* AsyncHTTPRequest::respHeaderValue(const __FlashStringHelper *name)
{
if (_readyState < readyStateHdrsRecvd)
if (_readyState < ReadyState::HdrsRecvd)
return nullptr;
char* _name = _charstar(name);
@ -1062,7 +1068,7 @@ char* AsyncHTTPRequest::respHeaderValue(const __FlashStringHelper *name)
//**************************************************************************************************************
bool AsyncHTTPRequest::respHeaderExists(const __FlashStringHelper *name)
{
if (_readyState < readyStateHdrsRecvd)
if (_readyState < ReadyState::HdrsRecvd)
return false;
char* _name = _charstar(name);

43
src/AsyncHTTPRequest.h
View File

@ -30,7 +30,7 @@
#include <Arduino.h>
#include "AsyncHTTPRequest_Debug_Generic.h"
#include "AsyncHTTPRequest_Debug.h"
#ifndef DEBUG_IOTA_PORT
#define DEBUG_IOTA_PORT Serial
@ -85,14 +85,14 @@
#define HTTPCODE_STREAM_WRITE (-10)
#define HTTPCODE_TIMEOUT (-11)
typedef enum
enum class ReadyState
{
readyStateUnsent = 0, // Client created, open not yet called
readyStateOpened = 1, // open() has been called, connected
readyStateHdrsRecvd = 2, // send() called, response headers available
readyStateLoading = 3, // receiving, partial data available
readyStateDone = 4 // Request complete, all data available.
} reqStates;
Unsent = 0, // Client created, open not yet called
Opened = 1, // open() has been called, connected
HdrsRecvd = 2, // send() called, response headers available
Loading = 3, // receiving, partial data available
Done = 4 // Request complete, all data available.
};
class AsyncHTTPRequest
{
@ -140,8 +140,8 @@ class AsyncHTTPRequest
}
};
typedef std::function<void(void*, AsyncHTTPRequest*, int readyState)> readyStateChangeCB;
typedef std::function<void(void*, AsyncHTTPRequest*, size_t available)> onDataCB;
using readyStateChangeCB = std::function<void(void*, AsyncHTTPRequest*, ReadyState readyState)>;
using onDataCB = std::function<void(void*, AsyncHTTPRequest*, size_t available)>;
public:
AsyncHTTPRequest();
@ -151,12 +151,13 @@ class AsyncHTTPRequest
//External functions in typical order of use:
//__________________________________________________________________________________________________________*/
void setDebug(bool); // Turn debug message on/off
bool debug(); // is debug on or off?
bool debug() const; // is debug on or off?
bool open(const char* /*GET/POST*/, const char* URL); // Initiate a request
bool open(const char* method, const char* URL); // Initiate a request
void onReadyStateChange(readyStateChangeCB, void* arg = 0); // Optional event handler for ready state change
void onReadyStateChangeArg(void* arg = 0); // set event handlers arg
// or you can simply poll readyState()
void setTimeout(int); // overide default timeout (seconds)
void setTimeout(int seconds); // overide default timeout (seconds)
void setReqHeader(const char* name, const char* value); // add a request header
void setReqHeader(const char* name, int32_t value); // overload to use integer value
@ -175,7 +176,7 @@ class AsyncHTTPRequest
bool send(xbuf* body, size_t len); // Send the request (POST) data in an xbuf
void abort(); // Abort the current operation
reqStates readyState(); // Return the ready state
ReadyState readyState() const; // Return the ready state
int respHeaderCount(); // Retrieve count of response headers
char* respHeaderName(int index); // Return header name by index
@ -192,20 +193,20 @@ class AsyncHTTPRequest
String headers(); // Return all headers as String
void onData(onDataCB, void* arg = 0); // Notify when min data is available
size_t available(); // response available
size_t responseLength(); // indicated response length or sum of chunks to date
int responseHTTPcode(); // HTTP response code or (negative) error code
size_t available() const; // response available
size_t responseLength() const; // indicated response length or sum of chunks to date
int responseHTTPcode() const; // HTTP response code or (negative) error code
String responseText(); // response (whole* or partial* as string)
size_t responseRead(uint8_t* buffer, size_t len); // Read response into buffer
uint32_t elapsedTime(); // Elapsed time of in progress transaction or last completed (ms)
String version(); // Version of AsyncHTTPRequest
uint32_t elapsedTime() const; // Elapsed time of in progress transaction or last completed (ms)
String version() const; // Version of AsyncHTTPRequest
//___________________________________________________________________________________________________________________________________
private:
enum {HTTPmethodGET, HTTPmethodPOST} _HTTPmethod;
reqStates _readyState;
ReadyState _readyState;
int16_t _HTTPcode; // HTTP response code or (negative) exception code
bool _chunked; // Processing chunked response
@ -247,7 +248,7 @@ class AsyncHTTPRequest
void _processChunks();
bool _connect();
size_t _send();
void _setReadyState(reqStates);
void _setReadyState(ReadyState readyState);
#if (ESP32 || ESP8266)
char* _charstar(const __FlashStringHelper *str);