- Move all serialization code to separate Serializer namespace and fi…

…les.

- Generalize and improve JSON processing code.

- Prevent mesh passwords from containing " characters to avoid messing up the JSON processing.

- Improve documentation.

libraries/ESP8266WiFiMesh/examples/HelloEspnow/HelloEspnow.ino

@@ -19,7 +19,7 @@ namespace TypeCast = MeshTypeConversionFunctions;
    https://arduino-esp8266.readthedocs.io/en/latest/PROGMEM.html
 */
 constexpr char exampleMeshName[] PROGMEM = "MeshNode_"; // The name of the mesh network. Used as prefix for the node SSID and to find other network nodes in the example networkFilter and broadcastFilter functions below.
-constexpr char exampleWiFiPassword[] PROGMEM = "ChangeThisWiFiPassword_TODO"; // The password has to be min 8 and max 64 characters long, otherwise an AP which uses it will not be found during scans.
+constexpr char exampleWiFiPassword[] PROGMEM = "ChangeThisWiFiPassword_TODO"; // Note: " is an illegal character. The password has to be min 8 and max 64 characters long, otherwise an AP which uses it will not be found during scans.
 
 // A custom encryption key is required when using encrypted ESP-NOW transmissions. There is always a default Kok set, but it can be replaced if desired.
 // All ESP-NOW keys below must match in an encrypted connection pair for encrypted communication to be possible.

libraries/ESP8266WiFiMesh/examples/HelloMesh/HelloMesh.ino

@@ -26,7 +26,7 @@ namespace TypeCast = MeshTypeConversionFunctions;
    https://arduino-esp8266.readthedocs.io/en/latest/PROGMEM.html
 */
 constexpr char exampleMeshName[] PROGMEM = "MeshNode_"; // The name of the mesh network. Used as prefix for the node SSID and to find other network nodes in the example networkFilter and broadcastFilter functions below.
-constexpr char exampleWiFiPassword[] PROGMEM = "ChangeThisWiFiPassword_TODO"; // The password has to be min 8 and max 64 characters long, otherwise an AP which uses it will not be found during scans.
+constexpr char exampleWiFiPassword[] PROGMEM = "ChangeThisWiFiPassword_TODO"; // Note: " is an illegal character. The password has to be min 8 and max 64 characters long, otherwise an AP which uses it will not be found during scans.
 
 // A custom encryption key is required when using encrypted ESP-NOW transmissions. There is always a default Kok set, but it can be replaced if desired.
 // All ESP-NOW keys below must match in an encrypted connection pair for encrypted communication to be possible.

libraries/ESP8266WiFiMesh/examples/HelloTcpIp/HelloTcpIp.ino

@@ -19,7 +19,7 @@ namespace TypeCast = MeshTypeConversionFunctions;
    https://arduino-esp8266.readthedocs.io/en/latest/PROGMEM.html
 */
 constexpr char exampleMeshName[] PROGMEM = "MeshNode_";
-constexpr char exampleWiFiPassword[] PROGMEM = "ChangeThisWiFiPassword_TODO";
+constexpr char exampleWiFiPassword[] PROGMEM = "ChangeThisWiFiPassword_TODO"; // Note: " is an illegal character. The password has to be min 8 and max 64 characters long, otherwise an AP which uses it will not be found during scans.
 
 unsigned int requestNumber = 0;
 unsigned int responseNumber = 0;

libraries/ESP8266WiFiMesh/src/EncryptedConnectionData.cpp

@@ -27,6 +27,7 @@
 #include "TypeConversionFunctions.h"
 #include "JsonTranslator.h"
 #include "MeshCryptoInterface.h"
+#include "Serializer.h"
 
 namespace
 {
@@ -157,16 +158,8 @@ bool EncryptedConnectionData::desync() const { return _desync; }
 
 String EncryptedConnectionData::serialize() const
 {
-  // Returns: {"connectionState":{"duration":"123","password":"abc","ownSK":"1A2","peerSK":"3B4","peerStaMac":"F2","peerApMac":"E3"}}
-
-  return 
-  String(FPSTR(JsonTranslator::jsonConnectionState))
-  + (temporary() ? String(FPSTR(JsonTranslator::jsonDuration)) + '\"' + String(temporary()->remainingDuration()) + F("\",") : emptyString)
-  + FPSTR(JsonTranslator::jsonDesync) + '\"' + String(desync()) + F("\",") 
-  + FPSTR(JsonTranslator::jsonOwnSessionKey) + '\"' + TypeCast::uint64ToString(getOwnSessionKey()) + F("\",") 
-  + FPSTR(JsonTranslator::jsonPeerSessionKey) + '\"' + TypeCast::uint64ToString(getPeerSessionKey()) + F("\",") 
-  + FPSTR(JsonTranslator::jsonPeerStaMac) + '\"' + TypeCast::macToString(_peerStaMac) + F("\",") 
-  + FPSTR(JsonTranslator::jsonPeerApMac) + '\"' + TypeCast::macToString(_peerApMac) +  F("\"}}");
+  return Serializer:: serializeEncryptedConnection((temporary() ? String(temporary()->remainingDuration()) : emptyString), String(desync()), TypeCast::uint64ToString(getOwnSessionKey()), 
+                                                   TypeCast::uint64ToString(getPeerSessionKey()), TypeCast::macToString(_peerStaMac), TypeCast::macToString(_peerApMac));
 }
 
 const ExpiringTimeTracker *EncryptedConnectionData::temporary() const

libraries/ESP8266WiFiMesh/src/EspnowMeshBackend.cpp

@@ -27,6 +27,8 @@ extern "C" {
 #include "MutexTracker.h"
 #include "JsonTranslator.h"
 #include "MeshCryptoInterface.h"
+#include "EspnowUtility.h"
+#include "Serializer.h"
 
 namespace
 {
@@ -1112,7 +1114,7 @@ TransmissionStatusType EspnowMeshBackend::espnowSendToNode(const String &message
 TransmissionStatusType EspnowMeshBackend::espnowSendToNodeUnsynchronized(const String message, const uint8_t *targetBSSID, const char messageType, const uint64_t messageID, EspnowMeshBackend *espnowInstance)
 {
   using namespace EspnowProtocolInterpreter;
-  
+
   MutexTracker mutexTracker(_espnowSendToNodeMutex);
   if(!mutexTracker.mutexCaptured())
   {
@@ -1773,7 +1775,7 @@ EncryptedConnectionStatus EspnowMeshBackend::requestEncryptedConnectionKernel(co
       requestMessage = encryptionRequestBuilder(requestNonce, existingTimeTracker);
     else if(_ongoingPeerRequestResult == EncryptedConnectionStatus::SOFT_LIMIT_CONNECTION_ESTABLISHED)
       // We will only get a soft limit connection. Adjust future actions based on this.
-      requestMessage = JsonTranslator::createEncryptionRequestHmacMessage(FPSTR(temporaryEncryptionRequestHeader), requestNonce, getEspnowHashKey(), 
+      requestMessage = Serializer::createEncryptionRequestHmacMessage(FPSTR(temporaryEncryptionRequestHeader), requestNonce, getEspnowHashKey(), 
                                                                           hashKeyLength, getAutoEncryptionDuration());
     else
       assert(false && String(F("Unknown _ongoingPeerRequestResult during encrypted connection finalization!")));
@@ -1848,7 +1850,7 @@ String EspnowMeshBackend::defaultEncryptionRequestBuilder(const String &requestH
 {
   (void)existingTimeTracker; // This removes a "unused parameter" compiler warning. Does nothing else.
 
-  return JsonTranslator::createEncryptionRequestHmacMessage(requestHeader, requestNonce, hashKey, hashKeyLength, durationMs);
+  return Serializer::createEncryptionRequestHmacMessage(requestHeader, requestNonce, hashKey, hashKeyLength, durationMs);
 }
 
 String EspnowMeshBackend::flexibleEncryptionRequestBuilder(const uint32_t minDurationMs, const uint8_t *hashKey, 
@@ -1860,7 +1862,7 @@ String EspnowMeshBackend::flexibleEncryptionRequestBuilder(const uint32_t minDur
   uint32_t connectionDuration = minDurationMs >= existingTimeTracker.remainingDuration() ? 
                                 minDurationMs : existingTimeTracker.remainingDuration();
 
-  return createEncryptionRequestHmacMessage(FPSTR(temporaryEncryptionRequestHeader), requestNonce, hashKey, hashKeyLength, connectionDuration);
+  return Serializer::createEncryptionRequestHmacMessage(FPSTR(temporaryEncryptionRequestHeader), requestNonce, hashKey, hashKeyLength, connectionDuration);
 }
 
 EncryptedConnectionStatus EspnowMeshBackend::requestEncryptedConnection(const uint8_t *peerMac)
@@ -2437,13 +2439,13 @@ void EspnowMeshBackend::sendPeerRequestConfirmations(const ExpiringTimeTracker *
     if(!existingEncryptedConnection && 
        ((reciprocalPeerRequest && encryptedConnections.size() >= maxEncryptedConnections) || (!reciprocalPeerRequest && reservedEncryptedConnections() >= maxEncryptedConnections)))
     {
-      espnowSendToNodeUnsynchronized(JsonTranslator::createEncryptionRequestHmacMessage(FPSTR(maxConnectionsReachedHeader), 
+      espnowSendToNodeUnsynchronized(Serializer::createEncryptionRequestHmacMessage(FPSTR(maxConnectionsReachedHeader), 
                                                         confirmationsIterator->getPeerRequestNonce(), hashKey, hashKeyLength),
                                                         defaultBSSID, 'C', generateMessageID(nullptr)); // Generates a new message ID to avoid sending encrypted sessionKeys over unencrypted connections.
 
       confirmationsIterator = peerRequestConfirmationsToSend.erase(confirmationsIterator);
     }
-    else if(espnowSendToNodeUnsynchronized(JsonTranslator::createEncryptionRequestHmacMessage(FPSTR(basicConnectionInfoHeader),
+    else if(espnowSendToNodeUnsynchronized(Serializer::createEncryptionRequestHmacMessage(FPSTR(basicConnectionInfoHeader),
                                                               confirmationsIterator->getPeerRequestNonce(), hashKey, hashKeyLength),
                                                               sendToDefaultBSSID ? defaultBSSID : unencryptedBSSID, 'C', generateMessageID(nullptr)) // Generates a new message ID to avoid sending encrypted sessionKeys over unencrypted connections.
                                                               == TransmissionStatusType::TRANSMISSION_COMPLETE)
@@ -2475,7 +2477,7 @@ void EspnowMeshBackend::sendPeerRequestConfirmations(const ExpiringTimeTracker *
       if(!existingEncryptedConnection)
       {
         // Send "node full" message
-        espnowSendToNodeUnsynchronized(JsonTranslator::createEncryptionRequestHmacMessage(FPSTR(maxConnectionsReachedHeader), 
+        espnowSendToNodeUnsynchronized(Serializer::createEncryptionRequestHmacMessage(FPSTR(maxConnectionsReachedHeader), 
                                                           confirmationsIterator->getPeerRequestNonce(), hashKey, hashKeyLength), 
                                                           defaultBSSID, 'C', generateMessageID(nullptr)); // Generates a new message ID to avoid sending encrypted sessionKeys over unencrypted connections.
       }
@@ -2503,7 +2505,7 @@ void EspnowMeshBackend::sendPeerRequestConfirmations(const ExpiringTimeTracker *
 
         // Send password and keys.
         // Probably no need to know which connection type to use, that is stored in request node and will be sent over for finalization.
-        espnowSendToNodeUnsynchronized(JsonTranslator::createEncryptedConnectionInfo(messageHeader,
+        espnowSendToNodeUnsynchronized(Serializer::createEncryptedConnectionInfo(messageHeader,
                                                           confirmationsIterator->getPeerRequestNonce(), confirmationsIterator->getAuthenticationPassword(), 
                                                           existingEncryptedConnection->getOwnSessionKey(), existingEncryptedConnection->getPeerSessionKey()),
                                                           defaultBSSID, 'C', generateMessageID(nullptr));  // Generates a new message ID to avoid sending encrypted sessionKeys over unencrypted connections.
@@ -2678,12 +2680,8 @@ void EspnowMeshBackend::resetTransmissionFailRate()
 }
 
 String EspnowMeshBackend::serializeUnencryptedConnection()
-{
-  using namespace JsonTranslator;
-
-  // Returns: {"connectionState":{"unsyncMsgID":"123"}}
-
-  return String(FPSTR(jsonConnectionState)) + createJsonEndPair(FPSTR(jsonUnsynchronizedMessageID), String(_unsynchronizedMessageID));
+{  
+  return Serializer::serializeUnencryptedConnection(String(_unsynchronizedMessageID));
 }
 
 String EspnowMeshBackend::serializeEncryptedConnection(const uint8_t *peerMac)

libraries/ESP8266WiFiMesh/src/EspnowMeshBackend.h

@@ -657,11 +657,11 @@ class EspnowMeshBackend : public MeshBackendBase {
    * @param intervalMs The time to wait for an ack after having made an ESP-NOW transmission, in milliseconds. Defaults to 15 ms.
    */
   static void setEspnowRetransmissionInterval(const uint32_t intervalMs);
-  static uint32_t getEspnowRetransmissionInterval(); 
+  static uint32_t getEspnowRetransmissionInterval();
 
   // The maximum amount of time each of the two stages in an encrypted connection request may take.
   static void setEncryptionRequestTimeout(const uint32_t timeoutMs);
-  static uint32_t getEncryptionRequestTimeout(); 
+  static uint32_t getEncryptionRequestTimeout();
 
   void setAutoEncryptionDuration(const uint32_t duration);
   uint32_t getAutoEncryptionDuration() const;
@@ -1217,7 +1217,7 @@ class EspnowMeshBackend : public MeshBackendBase {
    * @param peerMac The MAC of the node with which an encrypted connection should be established.
    * @param encryptionRequestBuilder A function which is responsible for constructing the request message to send. 
    * Called twice when the request is successful. First to build the initial request message and then to build the connection verification message.
-   * The request message should typically be of the form: JsonTranslator::createEncryptionRequestIntro() + JsonTranslator::createEncryptionRequestEnding().
+   * The request message should typically be of the form found in Serializer::createEncryptionRequestHmacMessage.
    * @return The ultimate status of the requested encrypted connection, as EncryptedConnectionStatus.
    */
   EncryptedConnectionStatus requestEncryptedConnectionKernel(const uint8_t *peerMac, const encryptionRequestBuilderType &encryptionRequestBuilder);

libraries/ESP8266WiFiMesh/src/FloodingMesh.cpp

@@ -25,6 +25,7 @@
 #include "FloodingMesh.h"
 #include "TypeConversionFunctions.h"
 #include "JsonTranslator.h"
+#include "Serializer.h"
 
 namespace
 {
@@ -153,16 +154,11 @@ void FloodingMesh::performMeshInstanceMaintenance()
 
 String FloodingMesh::serializeMeshState() const
 {
-  using namespace JsonTranslator;
-
-  // Returns: {"meshState":{"connectionState":{"unsyncMsgID":"123"},"meshMsgCount":"123"}}
-
   String connectionState = getEspnowMeshBackendConst().serializeUnencryptedConnection();
+  uint32_t unsyncMsgID = 0;
+  JsonTranslator::getUnsynchronizedMessageID(connectionState, unsyncMsgID);
 
-  return 
-  String(F("{\"meshState\":{"))
-  + connectionState.substring(1, connectionState.length() - 1) + String(',')
-  + createJsonEndPair(FPSTR(jsonMeshMessageCount), String(_messageCount));
+  return Serializer::serializeMeshState(String(unsyncMsgID), String(_messageCount));
 }
 
 void FloodingMesh::loadMeshState(const String &serializedMeshState)