Merge branch 'release/2.x' into dev

Author: halx99

CHANGELOG.md

@@ -1,4 +1,4 @@
-# axmol-2.9.0 ?? 2025
+# axmol-2.9.0 Oct.5 2025
 
 ## Significant changes relative to 2.8.x:
 
@@ -27,6 +27,7 @@
 
 ## Improvements
 
+- Add Http setDataCallback for streaming data support by @halx99 in [#2805](https://github.com/axmolengine/axmol/pull/2805)
 - Improve ios EditBox orientation handling with keyboard by @halx99 in [#2791](https://github.com/axmolengine/axmol/pull/2791) and [#2795](https://github.com/axmolengine/axmol/pull/2795)
 - Add support for extracting the previous scene from the scene stack by @rh101 in [#2793](https://github.com/axmolengine/axmol/pull/2793)
 - Destroy `ScriptEngine` instance before `_scheduler` to respect dependency by @halx99

axmol/network/HttpClient.cpp

@@ -258,7 +258,13 @@ void HttpClient::handleNetworkEvent(yasio::io_event* event)
         if (!responseFinished)
         {
             auto&& pkt = event->packet_view();
-            response->handleInput(pkt.data(), pkt.size());
+            auto err = response->input(pkt.data(), pkt.size());
+            if (err != HPE_OK)
+            {
+                response->updateInternalCode(err);
+                _service->close(event->cindex());
+                break;
+            }
         }
         if (response->isFinished())
         {
@@ -389,6 +395,7 @@ void HttpClient::handleNetworkEvent(yasio::io_event* event)
         }
         break;
     case YEK_ON_CLOSE:
+        response->handleConnectionClose();
         handleNetworkEOF(response, channel, event->status());
         break;
     }
@@ -460,8 +467,8 @@ void HttpClient::finishResponse(HttpResponse* response)
 
 void HttpClient::invokeResposneCallbackAndRelease(HttpResponse* response)
 {
-    HttpRequest* request                  = response->getHttpRequest();
-    const ccHttpRequestCallback& callback = request->getCallback();
+    auto request   = response->getHttpRequest();
+    auto& callback = request->getCompleteCallback();
 
     if (callback != nullptr)
         callback(this, response);

axmol/network/HttpClient.h

@@ -120,7 +120,6 @@ class AX_DLL HttpClient
      *      https://stackoverflow.com/questions/23714383/what-are-all-the-possible-values-for-http-content-type-header
      */
     void send(HttpRequest* request);
-    void sendImmediate(HttpRequest* request) { this->send(request); }
 
     /**
      * Set the timeout value for connecting.

axmol/network/HttpRequest.h

@@ -53,7 +53,9 @@ namespace network
 class HttpClient;
 class HttpResponse;
 
-typedef std::function<void(HttpClient* client, HttpResponse* response)> ccHttpRequestCallback;
+using HttpCompleteCallback  = std::function<void(HttpClient* client, HttpResponse* response)>;
+using HttpDataCallback      = std::function<void(HttpResponse* response, const char* data, size_t data_size)>;
+using ccHttpRequestCallback = HttpCompleteCallback;
 
 /**
  * Defines the object which users must packed for HttpClient::send(HttpRequest*) method.
@@ -205,16 +207,60 @@ class AX_DLL HttpRequest : public ConcurrentRefCountedBase
      * Set response callback function of HttpRequest object.
      * When response come back, we would call _pCallback to process response data.
      *
-     * @param callback the ccHttpRequestCallback function.
+     * @param callback the HttpCompleteCallback function.
      */
-    void setResponseCallback(const ccHttpRequestCallback& callback) { _pCallback = callback; }
+    void setCompleteCallback(const HttpCompleteCallback& callback) { _pCallback = callback; }
+    AX_DEPRECATED(2.9) void setResponseCallback(const HttpCompleteCallback& callback) { setCompleteCallback(callback); }
 
     /**
-     * Get ccHttpRequestCallback callback function.
+     * Get HttpCompleteCallback callback function.
      *
-     * @return const ccHttpRequestCallback& ccHttpRequestCallback callback function.
+     * @return const HttpCompleteCallback& completeCallback callback function.
      */
-    const ccHttpRequestCallback& getCallback() const { return _pCallback; }
+
+    const HttpCompleteCallback& getCompleteCallback() const { return _pCallback; }
+    AX_DEPRECATED(2.9) const HttpCompleteCallback& getCallback() const { return getCompleteCallback(); }
+
+    /**
+     * @brief Set the data callback for handling received data chunks.
+     *
+     * When a data callback is set, it will be invoked for each chunk of data received
+     * during the HTTP response. This is particularly useful for:
+     * - Large file downloads to process data incrementally
+     * - Streaming data processing
+     * - Memory-constrained environments
+     *
+     * @note If a data callback is set, the default behavior of appending received data
+     *       to HttpResponse::_responseData will be disabled. The response data buffer
+     *       will not accumulate data chunks automatically. You must handle all data
+     *       storage/processing within the callback function.
+     *
+     * @note The callback receives the following parameters:
+     *       - HttpResponse* response: The response object containing request context
+     *       - const char* data: Pointer to the received data chunk
+     *       - size_t data_size: Size of the data chunk in bytes
+     *
+     * @param callback The callback function to handle received data chunks
+     *
+     * @code
+     * // Example: Stream data to file instead of memory
+     * request->setDataCallback([](HttpResponse* response, const char* data, size_t size) {
+     *     // 0 for chunked transfer encoding, unknown size, or no Content-Length header
+     *     auto expectedTotal = response->getContentLength(); 
+     *     // Write directly to file, avoiding memory accumulation
+     *     fwrite(data, 1, size, outputFile);
+     *
+     *     // Update progress
+     *     totalReceived += size;
+     *     updateProgress(totalReceived, expectedTotal);
+     * });
+     * @endcode
+     *
+     * @see HttpDataCallback
+     * @see HttpResponse::_responseData
+     */
+    void setDataCallback(const HttpDataCallback& callback) { _pDataCallback = callback; }
+    const HttpDataCallback& getDataCallback() const { return _pDataCallback; }
 
     /**
      * Set custom-defined headers.
@@ -258,6 +304,7 @@ class AX_DLL HttpRequest : public ConcurrentRefCountedBase
     yasio::sbyte_buffer _requestData;   /// used for POST
     std::string _tag;                   /// user defined tag, to identify different requests in response callback
     ccHttpRequestCallback _pCallback;   /// C++11 style callbacks
+    HttpDataCallback _pDataCallback;
     void* _pUserData;                   /// You can add your customed data here
     std::vector<std::string> _headers;  /// custom http headers
     std::vector<std::string> _hosts;

axmol/network/HttpResponse.h

@@ -131,6 +131,8 @@ class AX_DLL HttpResponse : public ConcurrentRefCountedBase
 
     const std::string& getStatusText() const { return _statusText; }
 
+    uint64_t getContentLength() const { return _context.content_length; }
+
 private:
     void setResponseCode(int value) { _responseCode = value; }
 
@@ -145,13 +147,9 @@ class AX_DLL HttpResponse : public ConcurrentRefCountedBase
      */
     bool isFinished() const { return _finished; }
 
-    void handleInput(const char* d, size_t n)
+    llhttp_errno_t input(const char* d, size_t n)
     {
-        enum llhttp_errno err = llhttp_execute(&_context, d, n);
-        if (err != HPE_OK)
-        {
-            _finished = true;
-        }
+        return llhttp_execute(&_context, d, n);
     }
 
     bool tryRedirect()
@@ -194,6 +192,7 @@ class AX_DLL HttpResponse : public ConcurrentRefCountedBase
             /* Resets response status */
             _responseHeaders.clear();
             _finished = false;
+            _contentLength = 0;
             _responseData.clear();
             _currentHeader.clear();
             _statusText.clear();
@@ -216,6 +215,7 @@ class AX_DLL HttpResponse : public ConcurrentRefCountedBase
             _contextSettings.on_header_field_complete = on_header_field_complete;
             _contextSettings.on_header_value          = on_header_value;
             _contextSettings.on_header_value_complete = on_header_value_complete;
+            _contextSettings.on_headers_complete      = on_headers_complete;
             _contextSettings.on_body                  = on_body;
             _contextSettings.on_status                = on_status;
             _contextSettings.on_message_complete      = on_complete;
@@ -228,6 +228,16 @@ class AX_DLL HttpResponse : public ConcurrentRefCountedBase
 
     const Uri& getRequestUri() const { return _requestUri; }
 
+    void handleConnectionClose()
+    {
+        if (_finished)
+            return;
+        if (llhttp_message_needs_eof(&_context))
+            llhttp_finish(&_context);
+        else
+            _internalCode = -1;
+    }
+
     static int on_status(llhttp_t* context, const char* at, size_t length)
     {
         auto thiz = (HttpResponse*)context->data;
@@ -258,12 +268,27 @@ class AX_DLL HttpResponse : public ConcurrentRefCountedBase
     {
         auto thiz = (HttpResponse*)context->data;
         thiz->_responseHeaders.emplace(std::move(thiz->_currentHeader), std::move(thiz->_currentHeaderValue));
+        
+        return 0;
+    }
+    static int on_headers_complete(llhttp_t* context)
+    {
+        auto thiz            = (HttpResponse*)context->data;
+        thiz->_contentLength = context->content_length;
+        auto request         = thiz->getHttpRequest();
+        if (!request->getDataCallback() && thiz->_contentLength > 0)
+            thiz->_responseData.reserve(thiz->_contentLength);
         return 0;
     }
     static int on_body(llhttp_t* context, const char* at, size_t length)
     {
         auto thiz = (HttpResponse*)context->data;
-        thiz->_responseData.insert(thiz->_responseData.end(), at, at + length);
+        auto request = thiz->getHttpRequest();
+        auto dataCallback = request->getDataCallback();
+        if (!dataCallback)
+            thiz->_responseData.insert(thiz->_responseData.end(), at, at + length);
+        else
+            dataCallback(thiz, at, length);
         return 0;
     }
     static int on_complete(llhttp_t* context)
@@ -281,6 +306,7 @@ class AX_DLL HttpResponse : public ConcurrentRefCountedBase
 
     Uri _requestUri;
     bool _finished = false;             /// to indicate if the http request is successful simply
+    uint64_t _contentLength{0};
     yasio::sbyte_buffer _responseData;  /// the returned raw data. You can also dump it as a string
     std::string _currentHeader;
     std::string _currentHeaderValue;