Merge branch 'dev2' of https://github.com/emsesp/EMS-ESP32 into dev2

lib/ArduinoJson/src/ArduinoJson/Variant/VariantCompare.hpp

@@ -20,188 +20,198 @@ template <typename T, typename Enable = void>
 struct Comparer;
 
 template <typename T>
-struct Comparer<T, typename enable_if<IsString<T>::value>::type>
-    : ComparerBase {
-  T rhs;  // TODO: store adapted string?
+struct Comparer<T, typename enable_if<IsString<T>::value>::type> : ComparerBase {
+    T rhs;
 
-  explicit Comparer(T value) : rhs(value) {}
+    explicit Comparer(T value)
+        : rhs(value) {
+    }
 
-  CompareResult visitString(const char* lhs, size_t n) {
-    int i = stringCompare(adaptString(rhs), adaptString(lhs, n));
-    if (i < 0)
-      return COMPARE_RESULT_GREATER;
-    else if (i > 0)
-      return COMPARE_RESULT_LESS;
-    else
-      return COMPARE_RESULT_EQUAL;
-  }
+    CompareResult visitString(const char * lhs, size_t n) {
+        int i = stringCompare(adaptString(rhs), adaptString(lhs, n));
+        if (i < 0)
+            return COMPARE_RESULT_GREATER;
+        else if (i > 0)
+            return COMPARE_RESULT_LESS;
+        else
+            return COMPARE_RESULT_EQUAL;
+    }
 
-  CompareResult visitNull() {
-    if (adaptString(rhs).isNull())
-      return COMPARE_RESULT_EQUAL;
-    else
-      return COMPARE_RESULT_DIFFER;
-  }
+    CompareResult visitNull() {
+        if (adaptString(rhs).isNull())
+            return COMPARE_RESULT_EQUAL;
+        else
+            return COMPARE_RESULT_DIFFER;
+    }
 };
 
 template <typename T>
-struct Comparer<T, typename enable_if<is_integral<T>::value ||
-                                      is_floating_point<T>::value>::type>
-    : ComparerBase {
-  T rhs;
+struct Comparer<T, typename enable_if<is_integral<T>::value || is_floating_point<T>::value>::type> : ComparerBase {
+    T rhs;
 
-  explicit Comparer(T value) : rhs(value) {}
+    explicit Comparer(T value)
+        : rhs(value) {
+    }
 
-  CompareResult visitFloat(JsonFloat lhs) {
-    return arithmeticCompare(lhs, rhs);
-  }
+    CompareResult visitFloat(JsonFloat lhs) {
+        return arithmeticCompare(lhs, rhs);
+    }
 
-  CompareResult visitSignedInteger(JsonInteger lhs) {
-    return arithmeticCompare(lhs, rhs);
-  }
+    CompareResult visitSignedInteger(JsonInteger lhs) {
+        return arithmeticCompare(lhs, rhs);
+    }
 
-  CompareResult visitUnsignedInteger(JsonUInt lhs) {
-    return arithmeticCompare(lhs, rhs);
-  }
+    CompareResult visitUnsignedInteger(JsonUInt lhs) {
+        return arithmeticCompare(lhs, rhs);
+    }
 
-  CompareResult visitBoolean(bool lhs) {
-    return visitUnsignedInteger(static_cast<JsonUInt>(lhs));
-  }
+    CompareResult visitBoolean(bool lhs) {
+        return visitUnsignedInteger(static_cast<JsonUInt>(lhs));
+    }
 };
 
 struct NullComparer : ComparerBase {
-  CompareResult visitNull() {
-    return COMPARE_RESULT_EQUAL;
-  }
+    CompareResult visitNull() {
+        return COMPARE_RESULT_EQUAL;
+    }
 };
 
 template <>
 struct Comparer<decltype(nullptr), void> : NullComparer {
-  explicit Comparer(decltype(nullptr)) : NullComparer() {}
+    explicit Comparer(decltype(nullptr))
+        : NullComparer() {
+    }
 };
 
 struct ArrayComparer : ComparerBase {
-  const CollectionData* _rhs;
+    const CollectionData * _rhs;
 
-  explicit ArrayComparer(const CollectionData& rhs) : _rhs(&rhs) {}
+    explicit ArrayComparer(const CollectionData & rhs)
+        : _rhs(&rhs) {
+    }
 
-  CompareResult visitArray(const CollectionData& lhs) {
-    if (JsonArrayConst(&lhs) == JsonArrayConst(_rhs))
-      return COMPARE_RESULT_EQUAL;
-    else
-      return COMPARE_RESULT_DIFFER;
-  }
+    CompareResult visitArray(const CollectionData & lhs) {
+        if (JsonArrayConst(&lhs) == JsonArrayConst(_rhs))
+            return COMPARE_RESULT_EQUAL;
+        else
+            return COMPARE_RESULT_DIFFER;
+    }
 };
 
 struct ObjectComparer : ComparerBase {
-  const CollectionData* _rhs;
+    const CollectionData * _rhs;
 
-  explicit ObjectComparer(const CollectionData& rhs) : _rhs(&rhs) {}
+    explicit ObjectComparer(const CollectionData & rhs)
+        : _rhs(&rhs) {
+    }
 
-  CompareResult visitObject(const CollectionData& lhs) {
-    if (JsonObjectConst(&lhs) == JsonObjectConst(_rhs))
-      return COMPARE_RESULT_EQUAL;
-    else
-      return COMPARE_RESULT_DIFFER;
-  }
+    CompareResult visitObject(const CollectionData & lhs) {
+        if (JsonObjectConst(&lhs) == JsonObjectConst(_rhs))
+            return COMPARE_RESULT_EQUAL;
+        else
+            return COMPARE_RESULT_DIFFER;
+    }
 };
 
 struct RawComparer : ComparerBase {
-  const char* _rhsData;
-  size_t _rhsSize;
+    const char * _rhsData;
+    size_t       _rhsSize;
 
-  explicit RawComparer(const char* rhsData, size_t rhsSize)
-      : _rhsData(rhsData), _rhsSize(rhsSize) {}
+    explicit RawComparer(const char * rhsData, size_t rhsSize)
+        : _rhsData(rhsData)
+        , _rhsSize(rhsSize) {
+    }
 
-  CompareResult visitRawJson(const char* lhsData, size_t lhsSize) {
-    size_t size = _rhsSize < lhsSize ? _rhsSize : lhsSize;
-    int n = memcmp(lhsData, _rhsData, size);
-    if (n < 0)
-      return COMPARE_RESULT_LESS;
-    else if (n > 0)
-      return COMPARE_RESULT_GREATER;
-    else
-      return COMPARE_RESULT_EQUAL;
-  }
+    CompareResult visitRawJson(const char * lhsData, size_t lhsSize) {
+        size_t size = _rhsSize < lhsSize ? _rhsSize : lhsSize;
+        int    n    = memcmp(lhsData, _rhsData, size);
+        if (n < 0)
+            return COMPARE_RESULT_LESS;
+        else if (n > 0)
+            return COMPARE_RESULT_GREATER;
+        else
+            return COMPARE_RESULT_EQUAL;
+    }
 };
 
 struct VariantComparer : ComparerBase {
-  const VariantData* rhs;
+    const VariantData * rhs;
 
-  explicit VariantComparer(const VariantData* value) : rhs(value) {}
-
-  CompareResult visitArray(const CollectionData& lhs) {
-    ArrayComparer comparer(lhs);
-    return accept(comparer);
-  }
-
-  CompareResult visitObject(const CollectionData& lhs) {
-    ObjectComparer comparer(lhs);
-    return accept(comparer);
-  }
-
-  CompareResult visitFloat(JsonFloat lhs) {
-    Comparer<JsonFloat> comparer(lhs);
-    return accept(comparer);
-  }
-
-  CompareResult visitString(const char* lhs, size_t) {
-    Comparer<const char*> comparer(lhs);
-    return accept(comparer);
-  }
-
-  CompareResult visitRawJson(const char* lhsData, size_t lhsSize) {
-    RawComparer comparer(lhsData, lhsSize);
-    return accept(comparer);
-  }
-
-  CompareResult visitSignedInteger(JsonInteger lhs) {
-    Comparer<JsonInteger> comparer(lhs);
-    return accept(comparer);
-  }
-
-  CompareResult visitUnsignedInteger(JsonUInt lhs) {
-    Comparer<JsonUInt> comparer(lhs);
-    return accept(comparer);
-  }
-
-  CompareResult visitBoolean(bool lhs) {
-    Comparer<bool> comparer(lhs);
-    return accept(comparer);
-  }
-
-  CompareResult visitNull() {
-    NullComparer comparer;
-    return accept(comparer);
-  }
-
- private:
-  template <typename TComparer>
-  CompareResult accept(TComparer& comparer) {
-    CompareResult reversedResult = variantAccept(rhs, comparer);
-    switch (reversedResult) {
-      case COMPARE_RESULT_GREATER:
-        return COMPARE_RESULT_LESS;
-      case COMPARE_RESULT_LESS:
-        return COMPARE_RESULT_GREATER;
-      default:
-        return reversedResult;
+    explicit VariantComparer(const VariantData * value)
+        : rhs(value) {
+    }
+
+    CompareResult visitArray(const CollectionData & lhs) {
+        ArrayComparer comparer(lhs);
+        return accept(comparer);
+    }
+
+    CompareResult visitObject(const CollectionData & lhs) {
+        ObjectComparer comparer(lhs);
+        return accept(comparer);
+    }
+
+    CompareResult visitFloat(JsonFloat lhs) {
+        Comparer<JsonFloat> comparer(lhs);
+        return accept(comparer);
+    }
+
+    CompareResult visitString(const char * lhs, size_t) {
+        Comparer<const char *> comparer(lhs);
+        return accept(comparer);
+    }
+
+    CompareResult visitRawJson(const char * lhsData, size_t lhsSize) {
+        RawComparer comparer(lhsData, lhsSize);
+        return accept(comparer);
+    }
+
+    CompareResult visitSignedInteger(JsonInteger lhs) {
+        Comparer<JsonInteger> comparer(lhs);
+        return accept(comparer);
+    }
+
+    CompareResult visitUnsignedInteger(JsonUInt lhs) {
+        Comparer<JsonUInt> comparer(lhs);
+        return accept(comparer);
+    }
+
+    CompareResult visitBoolean(bool lhs) {
+        Comparer<bool> comparer(lhs);
+        return accept(comparer);
+    }
+
+    CompareResult visitNull() {
+        NullComparer comparer;
+        return accept(comparer);
+    }
+
+  private:
+    template <typename TComparer>
+    CompareResult accept(TComparer & comparer) {
+        CompareResult reversedResult = variantAccept(rhs, comparer);
+        switch (reversedResult) {
+        case COMPARE_RESULT_GREATER:
+            return COMPARE_RESULT_LESS;
+        case COMPARE_RESULT_LESS:
+            return COMPARE_RESULT_GREATER;
+        default:
+            return reversedResult;
+        }
     }
-  }
 };
 
 template <typename T>
-struct Comparer<T, typename enable_if<is_convertible<
-                       T, ArduinoJson::JsonVariantConst>::value>::type>
-    : VariantComparer {
-  explicit Comparer(const T& value)
-      : VariantComparer(VariantAttorney::getData(value)) {}
+struct Comparer<T, typename enable_if<is_convertible<T, ArduinoJson::JsonVariantConst>::value>::type> : VariantComparer {
+    explicit Comparer(const T & value)
+        : VariantComparer(VariantAttorney::getData(value)) {
+    }
 };
 
 template <typename T>
-CompareResult compare(ArduinoJson::JsonVariantConst lhs, const T& rhs) {
-  Comparer<T> comparer(rhs);
-  return variantAccept(VariantAttorney::getData(lhs), comparer);
+CompareResult compare(ArduinoJson::JsonVariantConst lhs, const T & rhs) {
+    Comparer<T> comparer(rhs);
+    return variantAccept(VariantAttorney::getData(lhs), comparer);
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

lib/framework/HttpEndpoint.h

@@ -115,7 +115,7 @@ class HttpPostEndpoint {
         response->setLength();
 
         if (outcome == StateUpdateResult::CHANGED_RESTART) {
-            response->setCode(202); // added by proddy
+            response->setCode(205); // added by proddy, reboot required
         }
         request->send(response);
     }

lib/framework/UploadFileService.cpp

@@ -42,12 +42,12 @@ void UploadFileService::handleUpload(AsyncWebServerRequest * request, const Stri
             return;
         } else {
             md5[0] = '\0';
-            return; // not support file type
+            return; // unsupported file type
         }
 
         if (is_firmware) {
             // Check firmware header, 0xE9 magic offset 0 indicates esp bin, chip offset 12: esp32:0, S2:2, C3:5
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#if CONFIG_IDF_TARGET_ESP32                // ESP32/PICO-D4
             if (len > 12 && (data[0] != 0xE9 || data[12] != 0)) {
                 handleError(request, 503); // service unavailable
                 return;
@@ -76,7 +76,7 @@ void UploadFileService::handleUpload(AsyncWebServerRequest * request, const Stri
                 }
                 request->onDisconnect(UploadFileService::handleEarlyDisconnect); // success, let's make sure we end the update if the client hangs up
             } else {
-                handleError(request, 507); // failed to begin, send an error response Insufficient Storage
+                handleError(request, 507);                                       // failed to begin, send an error response Insufficient Storage
                 return;
             }
         } else {
@@ -115,7 +115,7 @@ void UploadFileService::uploadComplete(AsyncWebServerRequest * request) {
     }
 
     // check if it was a firmware upgrade
-    // if no error, send the success response
+    // if no error, send the success response as a JSON
     if (is_firmware && !request->_tempObject) {
         request->onDisconnect(RestartService::restartNow);
         AsyncWebServerResponse * response = request->beginResponse(200);
@@ -123,8 +123,13 @@ void UploadFileService::uploadComplete(AsyncWebServerRequest * request) {
         return;
     }
     if (strlen(md5) == 32) {
-        AsyncWebServerResponse * response = request->beginResponse(201, "text/plain", md5); // created
+        auto *     response = new AsyncJsonResponse(false, 256);
+        JsonObject root     = response->getRoot();
+        root["md5"]         = md5;
+        response->setLength();
         request->send(response);
+        // AsyncWebServerResponse * response = request->beginResponse(201, "text/plain", md5); // created
+        // request->send(response);
         return;
     }
 

lib/framework/WiFiScanner.cpp

@@ -12,11 +12,12 @@ WiFiScanner::WiFiScanner(AsyncWebServer * server, SecurityManager * securityMana
 };
 
 void WiFiScanner::scanNetworks(AsyncWebServerRequest * request) {
+    request->send(202); // special code to indicate scan in progress
+
     if (WiFi.scanComplete() != -1) {
         WiFi.scanDelete();
         WiFi.scanNetworks(true);
     }
-    request->send(202);
 }
 
 void WiFiScanner::listNetworks(AsyncWebServerRequest * request) {
@@ -36,7 +37,7 @@ void WiFiScanner::listNetworks(AsyncWebServerRequest * request) {
         response->setLength();
         request->send(response);
     } else if (numNetworks == -1) {
-        request->send(202);
+        request->send(202); // special code to indicate scan in progress
     } else {
         scanNetworks(request);
     }