void saveConfig(MeteoConfig& cfg) { ActiveConfig = cfg; DynamicJsonBuffer jsonBuffer; JsonObject& root = jsonBuffer.createObject(); JsonObject& network = jsonBuffer.createObject(); root["network"] = network; network["ssid"] = cfg.NetworkSSID.c_str(); network["password"] = cfg.NetworkPassword.c_str(); JsonObject& correction = jsonBuffer.createObject(); root["correction"] = correction; correction["T1"] = cfg.AddT1; correction["T2"] = cfg.AddT2; correction["TZ"] = cfg.AddTZ; JsonObject& trigger = jsonBuffer.createObject(); root["trigger"] = trigger; trigger["type"] = (int)cfg.Trigger; trigger["min"] = cfg.RangeMin; trigger["max"] = cfg.RangeMax; char buf[3048]; root.prettyPrintTo(buf, sizeof(buf)); fileSetContent(METEO_CONFIG_FILE, buf); }
void BootConfig::_onDeviceInfoRequest() { Logger.logln("Received device info request"); DynamicJsonBuffer jsonBuffer; JsonObject& json = jsonBuffer.createObject(); json["device_id"] = Helpers.getDeviceId(); json["homie_version"] = VERSION; JsonObject& firmware = json.createNestedObject("firmware"); firmware["name"] = this->_shared_interface->fwname; firmware["version"] = this->_shared_interface->fwversion; JsonArray& nodes = json.createNestedArray("nodes"); for (int i = 0; i < this->_shared_interface->nodes.size(); i++) { HomieNode node = this->_shared_interface->nodes[i]; JsonObject& json_node = jsonBuffer.createObject(); json_node["id"] = node.id; json_node["type"] = node.type; nodes.add(json_node); } // 110 bytes for {"homie_version":"11.10.0","firmware":{"name":"awesome-light-great-top","version":"11.10.0-beta"},"nodes":[]} // 60 bytes for {"id":"lightifydefoulooooo","type":"lightifydefouloooo"}, (-1 for leading ","), +1 for terminator String jsonString; jsonString.reserve(110 + (60 * this->_shared_interface->nodes.size()) - 1 + 1); json.printTo(jsonString); this->_http.send(200, FPSTR(PROGMEM_CONFIG_APPLICATION_JSON), jsonString); }
void BootConfig::_onDeviceInfoRequest() { Logger.logln(F("Received device info request")); DynamicJsonBuffer jsonBuffer = DynamicJsonBuffer(JSON_OBJECT_SIZE(4) + JSON_OBJECT_SIZE(2) + JSON_ARRAY_SIZE(this->_interface->registeredNodesCount) + (this->_interface->registeredNodesCount * JSON_OBJECT_SIZE(2))); int jsonLength = 82; // {"device_id":"","homie_version":"","firmware":{"name":"","version":""},"nodes":[]} JsonObject& json = jsonBuffer.createObject(); jsonLength += strlen(Helpers::getDeviceId()); json["device_id"] = Helpers::getDeviceId(); jsonLength += strlen(VERSION); json["homie_version"] = VERSION; JsonObject& firmware = json.createNestedObject("firmware"); jsonLength += strlen(this->_interface->firmware.name); firmware["name"] = this->_interface->firmware.name; jsonLength += strlen(this->_interface->firmware.version); firmware["version"] = this->_interface->firmware.version; JsonArray& nodes = json.createNestedArray("nodes"); for (int i = 0; i < this->_interface->registeredNodesCount; i++) { jsonLength += 20; // {"id":"","type":""}, const HomieNode* node = this->_interface->registeredNodes[i]; JsonObject& jsonNode = jsonBuffer.createObject(); jsonLength += strlen(node->getId()); jsonNode["id"] = node->getId(); jsonLength += strlen(node->getType()); jsonNode["type"] = node->getType(); nodes.add(jsonNode); } jsonLength++; // \0 std::unique_ptr<char[]> jsonString(new char[jsonLength]); json.printTo(jsonString.get(), jsonLength); this->_http.send(200, FPSTR(PROGMEM_CONFIG_APPLICATION_JSON), jsonString.get()); }
void BootConfig::_generateNetworksJson() { DynamicJsonBuffer generatedJsonBuffer = DynamicJsonBuffer(JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(_ssidCount) + (_ssidCount * JSON_OBJECT_SIZE(3))); // 1 at root, 3 in childrend JsonObject& json = generatedJsonBuffer.createObject(); JsonArray& networks = json.createNestedArray("networks"); for (int network = 0; network < _ssidCount; network++) { JsonObject& jsonNetwork = generatedJsonBuffer.createObject(); jsonNetwork["ssid"] = WiFi.SSID(network); jsonNetwork["rssi"] = WiFi.RSSI(network); switch (WiFi.encryptionType(network)) { case ENC_TYPE_WEP: jsonNetwork["encryption"] = "wep"; break; case ENC_TYPE_TKIP: jsonNetwork["encryption"] = "wpa"; break; case ENC_TYPE_CCMP: jsonNetwork["encryption"] = "wpa2"; break; case ENC_TYPE_NONE: jsonNetwork["encryption"] = "none"; break; case ENC_TYPE_AUTO: jsonNetwork["encryption"] = "auto"; break; } networks.add(jsonNetwork); } delete[] _jsonWifiNetworks; size_t jsonBufferLength = json.measureLength() + 1; _jsonWifiNetworks = new char[jsonBufferLength]; json.printTo(_jsonWifiNetworks, jsonBufferLength); }
void handleRequest(AsyncWebServerRequest *request) { DynamicJsonBuffer jsonBuffer; JsonObject& json = jsonBuffer.createObject(); int res = 400; // JSON error // GET - get sensor value if (request->method() == HTTP_GET && request->params() == 0) { float val = _plugin->getValue(_sensor); if (isnan(val)) json["value"] = JSON_NULL; else { json["value"] = val; res = 200; } } // POST - set sensor UUID else if ((request->method() == HTTP_POST || request->method() == HTTP_GET) && request->params() == 1 && request->hasParam("uuid")) { String uuid = request->getParam(0)->value(); if (_plugin->setUuid(uuid.c_str(), _sensor)) { _plugin->getSensorJson(&json, _sensor); res = 200; } } jsonResponse(request, res, json); }
void Esp8266Configuration::write(){ DynamicJsonBuffer jsonBuffer; JsonObject& json = jsonBuffer.createObject(); json["wifi_ap_ssid"] = wifi_ap_ssid; json["wifi_ap_password"] = wifi_ap_password; json["wifi_ap_enabled"] = wifi_ap_enabled; json["wifi_station_ssid"] = wifi_station_ssid; json["wifi_station_password"] = wifi_station_password; json["wifi_station_enabled"] = wifi_station_enabled; json["mqtt_enabled"] = mqtt_enabled; json["mqtt_host"] = mqtt_host; json["mqtt_port"] = mqtt_port; json["mqtt_user"] = mqtt_user; json["mqtt_password"] = mqtt_password; // File configFile = SPIFFS.open("/configuration.json", "w"); if (!configFile) { Serial.println("failed to open config file for writing"); } // json.printTo(Serial); json.printTo(configFile); configFile.close(); }
bool simpleAuth::changePasswordHandler( Session &session,ESP8266WebServer *s,String &p){ DynamicJsonBuffer jsonBuffer; JsonObject& r = jsonBuffer.createObject(); r["exitcode"]="0"; r["exitmsg"]="OK password changed"; r["time"]=millis(); String callback=s->arg("callback"); if (s->arg("newpassword")==s->arg("newpassword2")){ String oldpass(s->arg("oldpassword")); String newpass(s->arg("newpassword")); bool chpass=this->changeUserPassword(session.user,oldpass,newpass); if (!chpass){ r["exitcode"]="20"; r["exitmsg"]="password change failed"; } } else{ r["exitcode"]="10"; r["exitmsg"]="new password repeat is not identical"; } String dstr; r.prettyPrintTo(dstr); s->send(200, "application/javascript",callback+"("+dstr+");"); return(true); }
//---------------------------------------------------------------------------- // //---------------------------------------------------------------------------- void CApplication::confSave() { DynamicJsonBuffer jsonBuffer; JsonObject& root = jsonBuffer.createObject(); root["cpuBoost"] = m_cpuBoost; root["otaBaseUrl"] = m_otaBaseUrl.c_str(); root["emul"] = m_gpiodEmul; root["mode"] = m_gpiodMode; root["lock"] = m_gpiodLock; root["disable"] = m_gpiodDisable; root["in0Debounce"] = m_gpiodInDebounce[0]; root["in1Debounce"] = m_gpiodInDebounce[1]; root["in2Debounce"] = m_gpiodInDebounce[2]; root["in3Debounce"] = m_gpiodInDebounce[3]; root["out0DefRun"] = m_gpiodOutDefRun[0]; root["out1DefRun"] = m_gpiodOutDefRun[1]; root["out2DefRun"] = m_gpiodOutDefRun[2]; root["out3DefRun"] = m_gpiodOutDefRun[3]; root["udm0DefRun"] = m_gpiodUdmDefRun[0]; root["udm1DefRun"] = m_gpiodUdmDefRun[1]; // write to file String strRoot; root.printTo(strRoot); fileSetContent(CAPP_CONF_FILE, strRoot); } // confSave
TEST(JsonVariant_As_Tests, ObjectAsJsonObject) { DynamicJsonBuffer buffer; JsonObject& arr = buffer.createObject(); JsonVariant variant = arr; ASSERT_EQ(&arr, &variant.as<JsonObject&>()); ASSERT_EQ(&arr, &variant.as<JsonObject>()); // <- shorthand }
TEST(StdStream, JsonObjectSubscript) { std::ostringstream os; DynamicJsonBuffer jsonBuffer; JsonObject& object = jsonBuffer.createObject(); object["key"] = "value"; os << object["key"]; ASSERT_EQ("\"value\"", os.str()); }
JsonObject& Record<T>::toJson() { DynamicJsonBuffer jsonBuffer; JsonObject& root = jsonBuffer.createObject(); root.set<long>("t", timestamp); root.set<T>("v", value); return root; }
/******************************************************************** sendPing keeps the websocket connection alive by pinging slack ********************************************************************/ void ArduinoSlackBot::sendPing() { DynamicJsonBuffer jsonBuffer; JsonObject& root = jsonBuffer.createObject(); root["type"] = "ping"; root["id"] = nextCmdId++; String json; root.printTo(json); webSocket.sendTXT(json); }
TEST(JsonVariant_As_Tests, ObjectAsString) { DynamicJsonBuffer buffer; JsonObject& obj = buffer.createObject(); obj["key"] = "value"; JsonVariant variant = obj; ASSERT_EQ(String("{\"key\":\"value\"}"), variant.as<String>()); }
/******************************************************************** sendMsg sends a message back to slack on a specific channel ********************************************************************/ void ArduinoSlackBot::sendMsg(const char *channel,const char *msg) { DynamicJsonBuffer jsonBuffer; JsonObject& root = jsonBuffer.createObject(); root["type"] = "message"; root["id"] = nextCmdId++; root["text"] = msg; root["channel"] = channel; String json; root.printTo(json); webSocket.sendTXT(json); }
void BootConfig::_generateNetworksJson() { DynamicJsonBuffer generatedJsonBuffer = DynamicJsonBuffer(JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(this->_ssidCount) + (this->_ssidCount * JSON_OBJECT_SIZE(3))); // 1 at root, 3 in childrend JsonObject& json = generatedJsonBuffer.createObject(); int jsonLength = 15; // {"networks":[]} JsonArray& networks = json.createNestedArray("networks"); for (int network = 0; network < this->_ssidCount; network++) { jsonLength += 36; // {"ssid":"","rssi":,"encryption":""}, JsonObject& jsonNetwork = generatedJsonBuffer.createObject(); jsonLength += WiFi.SSID(network).length(); jsonNetwork["ssid"] = WiFi.SSID(network); jsonLength += 4; jsonNetwork["rssi"] = WiFi.RSSI(network); jsonLength += 4; switch (WiFi.encryptionType(network)) { case ENC_TYPE_WEP: jsonNetwork["encryption"] = "wep"; break; case ENC_TYPE_TKIP: jsonNetwork["encryption"] = "wpa"; break; case ENC_TYPE_CCMP: jsonNetwork["encryption"] = "wpa2"; break; case ENC_TYPE_NONE: jsonNetwork["encryption"] = "none"; break; case ENC_TYPE_AUTO: jsonNetwork["encryption"] = "auto"; break; } networks.add(jsonNetwork); } jsonLength++; // \0 delete[] this->_jsonWifiNetworks; this->_jsonWifiNetworks = new char[jsonLength]; json.printTo(this->_jsonWifiNetworks, jsonLength); }
const FirebaseError FirebaseCloudMessaging::SendMessageToUser( const std::string& registration_id, const FirebaseCloudMessage& message) { DynamicJsonBuffer buffer; JsonObject& root = buffer.createObject(); root["to"] = registration_id.c_str(); AddToJson(message, root); char payload[root.measureLength() + 1]; root.printTo(payload, sizeof(payload)); return SendPayload(payload); }
void udp_recieve(UdpConnection& connection, char *data, int size, IPAddress remoteIP, uint16_t remotePort) { debugf("UDP Sever callback from %s:%d, %d bytes", remoteIP.toString().c_str(), remotePort, size); debugf("UDP Data: %s", data); DynamicJsonBuffer jsonBuffer; JsonObject& root = jsonBuffer.createObject(); if( !strcmp( data, "enum" ) ){ root.addCopy("ip", WifiStation.getIP().toString()); root.add("pos", driver_pos()); udp.sendStringTo(remoteIP, remotePort, root.toJsonString().c_str()); debugf("Sending to IP:%s:%d resp:%s", remoteIP.toString().c_str(), remotePort, root.toJsonString().c_str()); } else { debugf("UDP Unknown packet : %s", data); } }
String BootConfig::_generateNetworksJson() { DynamicJsonBuffer generatedJsonBuffer; JsonObject& json = generatedJsonBuffer.createObject(); JsonArray& networks = json.createNestedArray("networks"); for (int network = 0; network < this->_ssid_count; network++) { JsonObject& json_network = generatedJsonBuffer.createObject(); json_network["ssid"] = WiFi.SSID(network); json_network["rssi"] = WiFi.RSSI(network); switch (WiFi.encryptionType(network)) { case ENC_TYPE_WEP: json_network["encryption"] = "wep"; break; case ENC_TYPE_TKIP: json_network["encryption"] = "wpa"; break; case ENC_TYPE_CCMP: json_network["encryption"] = "wpa2"; break; case ENC_TYPE_NONE: json_network["encryption"] = "none"; break; case ENC_TYPE_AUTO: json_network["encryption"] = "auto"; break; } networks.add(json_network); } // 15 bytes: {"networks":[]} // 75 bytes: {"ssid":"thisisa32characterlongstringyes!","rssi":-99,"encryption":"none"}, (-1 for leading ","), +1 for terminator String json_string; json_string.reserve(15 + (75 * this->_ssid_count) - 1 + 1); json.printTo(json_string); return json_string; }
const FirebaseError FirebaseCloudMessaging::SendMessageToTopic( const std::string& topic, const FirebaseCloudMessage& message) { std::string to("/topics/"); to += topic; DynamicJsonBuffer buffer; JsonObject& root = buffer.createObject(); root["to"] = to.c_str(); AddToJson(message, root); char payload[root.measureLength() + 1]; root.printTo(payload, sizeof(payload)); return SendPayload(payload); }
TEST_F(JsonVariant_Comparison_Tests, ObjectInVariant) { DynamicJsonBuffer jsonBuffer; JsonObject& obj1 = jsonBuffer.createObject(); JsonObject& obj2 = jsonBuffer.createObject(); JsonVariant variant1 = obj1; JsonVariant variant2 = obj1; JsonVariant variant3 = obj2; ASSERT_TRUE(variant1 == variant2); ASSERT_FALSE(variant1 != variant2); ASSERT_TRUE(variant1 != variant3); ASSERT_FALSE(variant1 == variant3); }
const FirebaseError FirebaseCloudMessaging::SendMessageToUsers( const std::vector<std::string>& registration_ids, const FirebaseCloudMessage& message) { DynamicJsonBuffer buffer; JsonObject& root = buffer.createObject(); JsonArray& ids = root.createNestedArray("registration_ids"); for (const std::string& id : registration_ids) { ids.add(id.c_str()); } AddToJson(message, root); char payload[root.measureLength() + 1]; root.printTo(payload, sizeof(payload)); return SendPayload(payload); }
TEST_F(JsonVariant_Comparison_Tests, VariantsOfDifferentTypes) { DynamicJsonBuffer jsonBuffer; JsonVariant variants[] = { true, 42, 666.667, "hello", jsonBuffer.createArray(), jsonBuffer.createObject(), }; size_t n = sizeof(variants) / sizeof(variants[0]); for (size_t i = 0; i < n; i++) { for (size_t j = i + 1; j < n; j++) { ASSERT_TRUE(variants[i] != variants[j]); ASSERT_FALSE(variants[i] == variants[j]); } } }
bool IFTTTMaker::triggerEvent(String eventName , String value1, String value2, String value3){ DynamicJsonBuffer jsonBuffer; JsonObject& payload = jsonBuffer.createObject(); if(value1 != ""){ payload["value1"] = value1; } if(value2 != ""){ payload["value2"] = value2; } if(value3 != ""){ payload["value3"] = value3; } String response = sendTriggerEventWithData(eventName, payload); if(checkForSucessResponse(response)){ return true; } return false; }
void notify(String event, InstapushTrackers &trackersInfo) { debugf("preparing request"); setRequestContentType("application/json"); setRequestHeader("x-instapush-appid", app); setRequestHeader("x-instapush-appsecret", secret); DynamicJsonBuffer jsonBuffer; JsonObject& root = jsonBuffer.createObject(); root["event"] = event.c_str(); JsonObject& trackers = root.createNestedObject("trackers"); for (int i = 0; i < trackersInfo.count(); i++) { debugf("%s: %s", trackersInfo.keyAt(i).c_str(), trackersInfo.valueAt(i).c_str()); trackers.addCopy(trackersInfo.keyAt(i), trackersInfo[trackersInfo.keyAt(i)]); } setPostBody(root.toJsonString()); downloadString(url, HttpClientCompletedCallback(&InstapushApplication::processed, this)); }
// ArduinoJson - arduinojson.org // Copyright Benoit Blanchon 2014-2018 // MIT License #include <ArduinoJson.h> #include <catch.hpp> TEST_CASE("JsonObject basics") { DynamicJsonBuffer _jsonBuffer; JsonObject& _object = _jsonBuffer.createObject(); SECTION("InitialSizeIsZero") { REQUIRE(0 == _object.size()); } SECTION("SuccessIsTrue") { REQUIRE(_object.success()); } }
void parseTextMessage(AsyncWebSocketClient * client, uint8_t * data, size_t len) { DynamicJsonBuffer jsonBuffer; // parse possible json files if( data[0] =='{' && data[len - 1] == '}' ) { // let's parse the json file Serial.println("JSON STR RECEIVED!"); char tmp[len + 1]; memcpy(tmp, (char *)data, len); tmp[len] = '\0'; JsonObject& root = jsonBuffer.parseObject(tmp); // ######################## // Wifi configuration file // ######################## if ( root.containsKey("mode") ) { if ( strcmp((const char*)root["mode"], "ap") == 0 ) { Serial.println("AP"); storage.wifisett.setSSID((const char*)root["ssid"]); storage.wifisett.setPwd((const char*)root["pwd"]); storage.wifisett.enableSoftAP(); } else if ( strcmp((const char*)root["mode"], "sta") == 0 ) { Serial.println("STA"); storage.wifisett.setClientSSID((const char*)root["ssid"]); storage.wifisett.setClientPwd((const char*)root["pwd"]); // set mode to STA storage.wifisett.enableClient(); } } // ######################### // Set Clock // ######################### if (root.containsKey("setclock") ) { JsonObject& rootsetclock = root.get("setclock"); if ( rootsetclock.containsKey("type") && ( strcmp((const char*)rootsetclock["type"], "ntp") == 0 ) ) { // get ntp time opaq_controller.syncClock(); } else { // get values from json RtcDateTime tmp = RtcDateTime( rootsetclock["year"], rootsetclock["month"], rootsetclock["day"], rootsetclock["hour"], rootsetclock["minute"], rootsetclock["second"]); opaq_controller.getCom().setClock(tmp); } } // ######################### // Get Clock // ######################### if (root.containsKey("getclock") ) { // let's send the clock values JsonObject& tmp_root = jsonBuffer.createObject(); JsonObject& conf = tmp_root.createNestedObject("realtimeclock"); RtcDateTime date; opaq_controller.getCom().getClock(date); // [TODO] this can fail conf["second"] = date.Second(); conf["minute"] = date.Minute(); conf["hour"] = date.Hour(); conf["day"] = date.Day(); conf["month"] = date.Month(); conf["year"] = date.Year(); String tmp = ""; tmp_root.printTo(tmp); client->text(tmp); } // ################ // Filename getter // ################ if (root.containsKey("filename") ) { String content = ""; sendFile(SPIFFS, root["filename"], content); client->text(content); } // ################################ // Light device full dimmer setter // ############################### if (root.containsKey("adimid") ) { // let's write the file configuration storage.faqdim.save(root["adimid"], data, len); client->text("{\"success\":\"\"}"); } // ################################ // Light device full dimmer getter // ################################ if (root.containsKey("adim") ) { String content = "", dirname = ""; // list devices and send it // {"adim":["filea.json","fileb.json"]} content += F("{\"adim\":[\"\""); storage.faqdim.getDir(dirname); // for each file in /sett/adim directory do Dir directory = SPIFFS.openDir(dirname.c_str()); while ( directory.next() ) { content += F(", \""); content += directory.fileName(); content += F("\" "); } content += F(" ]}"); client->text(content); } // ################################## // Light device full dimmer remover // ################################# if (root.containsKey("adimremove") ) { storage.faqdim.remove(root["adimremove"]); client->text("{\"success\":\"\"}"); } // ################################ // Light device full dimmer setter // ################################ if (root.containsKey("adimadd") ) { storage.faqdim.add(); client->text("{\"success\":\"\"}"); } // #################################### // Light device full dimmer bind state // #################################### if (root.containsKey("adimbind") ) { //root["adimbind"] } // ################################ // Power device getter // ################################ if (root.containsKey("pdev") ) { String content = "", dirname = ""; // list devices and send it // {"pdev":["filea.json","fileb.json"]} content += F("{\"pdev\":[\"\""); storage.pwdevice.getDir(dirname); // for each file in /sett/pdev directory do Dir directory = SPIFFS.openDir(dirname.c_str()); while ( directory.next() ) { content += F(", \""); content += directory.fileName(); content += F("\" "); } content += F(" ]}"); client->text(content); } // ################################ // Power device setter // ################################ if (root.containsKey("pdevid") ) { // let's write the file configuration storage.pwdevice.save(root["pdevid"], data, len); client->text("{\"success\":\"\"}"); } // ################################ // Power device add setter // ################################ if (root.containsKey("pdevadd") ) { storage.pwdevice.add(); client->text("{\"success\":\"\"}"); } // ################################## // Power device remover // ################################# if (root.containsKey("pdevremove") ) { storage.pwdevice.remove(root["pdevremove"]); client->text("{\"success\":\"\"}"); } // ################################ // Update filesystem // ############################### if (root.containsKey("updatefilesystem") ) { // let's write the file configuration storage.setUpdate(true); client->text("{\"success\":\"\"}"); } } else if( strcmp((char*)data, "GET_OPAQ_WIFISETTINGS") == 0 ) { // let's send the wifisettings JsonObject& root = jsonBuffer.createObject(); JsonObject& conf = root.createNestedObject("wifisettings"); String wssid, wpwd, wclientssid, wclientpwd, wmode; storage.wifisett.getSSID(wssid); storage.wifisett.getPwd(wpwd); storage.wifisett.getClientSSID(wclientssid); storage.wifisett.getClientPwd(wclientpwd); storage.wifisett.getMode(wmode); conf["wssid"] = wssid.c_str(); conf["wpwd"] = wpwd.c_str(); conf["wchan"] = 6; // [TODO] conf["wssidsta"] = wclientssid.c_str(); conf["wpwdsta"] = wclientpwd.c_str(); conf["wmode"] = wmode.c_str(); String tmp = ""; root.printTo(tmp); client->text(tmp); } else if( strcmp((char*)data, "GET_OPAQ_SUMMARY") == 0 ) { String wssid; storage.wifisett.getSSID(wssid); JsonObject& root = jsonBuffer.createObject(); root["version"] = OPAQ_VERSION; root["id"] = ESP.getFlashChipId(); root["status"] = "Running without errors"; // [TODO] root["wstatus"] = "Radio is On"; // [TODO] root["wmode"] = (storage.wifisett.getModeOperation())? "softAP" : "client"; root["wssid"] = wssid.c_str(); root["wchan"] = WiFi.channel(); root["wdhcp"] = "Enabled"; // [TODO] root["wmac"] = WiFi.softAPmacAddress(); root["wip"] = (storage.wifisett.getModeOperation())? WiFi.softAPIP().toString() : WiFi.localIP().toString(); String tmp = ""; root.printTo(tmp); client->text(tmp); } else { client->text("{\"msg\":\"I got your text message\"}"); } }
void BootConfig::_onDeviceInfoRequest() { _interface->logger->logln(F("Received device info request")); auto numSettings = IHomieSetting::settings.size(); auto numNodes = HomieNode::nodes.size(); DynamicJsonBuffer jsonBuffer = DynamicJsonBuffer(JSON_OBJECT_SIZE(5) + JSON_OBJECT_SIZE(2) + JSON_ARRAY_SIZE(numNodes) + (numNodes * JSON_OBJECT_SIZE(2)) + JSON_ARRAY_SIZE(numSettings) + (numSettings * JSON_OBJECT_SIZE(5))); JsonObject& json = jsonBuffer.createObject(); json["device_id"] = Helpers::getDeviceId(); json["homie_esp8266_version"] = HOMIE_ESP8266_VERSION; JsonObject& firmware = json.createNestedObject("firmware"); firmware["name"] = _interface->firmware.name; firmware["version"] = _interface->firmware.version; JsonArray& nodes = json.createNestedArray("nodes"); for (HomieNode* iNode : HomieNode::nodes) { JsonObject& jsonNode = jsonBuffer.createObject(); jsonNode["id"] = iNode->getId(); jsonNode["type"] = iNode->getType(); nodes.add(jsonNode); } JsonArray& settings = json.createNestedArray("settings"); for (IHomieSetting* iSetting : IHomieSetting::settings) { JsonObject& jsonSetting = jsonBuffer.createObject(); if (iSetting->isBool()) { HomieSetting<bool>* setting = static_cast<HomieSetting<bool>*>(iSetting); jsonSetting["name"] = setting->getName(); jsonSetting["description"] = setting->getDescription(); jsonSetting["type"] = "bool"; jsonSetting["required"] = setting->isRequired(); if (!setting->isRequired()) { jsonSetting["default"] = setting->get(); } } else if (iSetting->isUnsignedLong()) { HomieSetting<unsigned long>* setting = static_cast<HomieSetting<unsigned long>*>(iSetting); jsonSetting["name"] = setting->getName(); jsonSetting["description"] = setting->getDescription(); jsonSetting["type"] = "ulong"; jsonSetting["required"] = setting->isRequired(); if (!setting->isRequired()) { jsonSetting["default"] = setting->get(); } } else if (iSetting->isLong()) { HomieSetting<long>* setting = static_cast<HomieSetting<long>*>(iSetting); jsonSetting["name"] = setting->getName(); jsonSetting["description"] = setting->getDescription(); jsonSetting["type"] = "long"; jsonSetting["required"] = setting->isRequired(); if (!setting->isRequired()) { jsonSetting["default"] = setting->get(); } } else if (iSetting->isDouble()) { HomieSetting<double>* setting = static_cast<HomieSetting<double>*>(iSetting); jsonSetting["name"] = setting->getName(); jsonSetting["description"] = setting->getDescription(); jsonSetting["type"] = "double"; jsonSetting["required"] = setting->isRequired(); if (!setting->isRequired()) { jsonSetting["default"] = setting->get(); } } else if (iSetting->isConstChar()) { HomieSetting<const char*>* setting = static_cast<HomieSetting<const char*>*>(iSetting); jsonSetting["name"] = setting->getName(); jsonSetting["description"] = setting->getDescription(); jsonSetting["type"] = "string"; jsonSetting["required"] = setting->isRequired(); if (!setting->isRequired()) { jsonSetting["default"] = setting->get(); } } settings.add(jsonSetting); } size_t jsonBufferLength = json.measureLength() + 1; std::unique_ptr<char[]> jsonString(new char[jsonBufferLength]); json.printTo(jsonString.get(), jsonBufferLength); _http.send(200, FPSTR(PROGMEM_CONFIG_APPLICATION_JSON), jsonString.get()); }
TEST(JsonVariant_Success_Tests, ReturnsTrue_WhenEmptyObject) { DynamicJsonBuffer jsonBuffer; JsonVariant variant = jsonBuffer.createObject(); EXPECT_TRUE(variant.success()); }