|  | @@ -0,0 +1,2906 @@
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * WiFiManager.cpp
 | 
	
		
			
				|  |  | + * 
 | 
	
		
			
				|  |  | + * WiFiManager, a library for the ESP8266/Arduino platform
 | 
	
		
			
				|  |  | + * for configuration of WiFi credentials using a Captive Portal
 | 
	
		
			
				|  |  | + * 
 | 
	
		
			
				|  |  | + * @author Creator tzapu
 | 
	
		
			
				|  |  | + * @author tablatronix
 | 
	
		
			
				|  |  | + * @version 0.0.0
 | 
	
		
			
				|  |  | + * @license MIT
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +#include "WiFiManager.h"
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +#if defined(ESP8266) || defined(ESP32)
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +#ifdef ESP32
 | 
	
		
			
				|  |  | +uint8_t WiFiManager::_lastconxresulttmp = WL_IDLE_STATUS;
 | 
	
		
			
				|  |  | +#endif
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * --------------------------------------------------------------------------------
 | 
	
		
			
				|  |  | + *  WiFiManagerParameter
 | 
	
		
			
				|  |  | + * --------------------------------------------------------------------------------
 | 
	
		
			
				|  |  | +**/
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +WiFiManagerParameter::WiFiManagerParameter() {
 | 
	
		
			
				|  |  | +  WiFiManagerParameter("");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +WiFiManagerParameter::WiFiManagerParameter(const char *custom) {
 | 
	
		
			
				|  |  | +  _id             = NULL;
 | 
	
		
			
				|  |  | +  _label          = NULL;
 | 
	
		
			
				|  |  | +  _length         = 1;
 | 
	
		
			
				|  |  | +  _value          = NULL;
 | 
	
		
			
				|  |  | +  _labelPlacement = WFM_LABEL_BEFORE;
 | 
	
		
			
				|  |  | +  _customHTML     = custom;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +WiFiManagerParameter::WiFiManagerParameter(const char *id, const char *label) {
 | 
	
		
			
				|  |  | +  init(id, label, "", 0, "", WFM_LABEL_BEFORE);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +WiFiManagerParameter::WiFiManagerParameter(const char *id, const char *label, const char *defaultValue, int length) {
 | 
	
		
			
				|  |  | +  init(id, label, defaultValue, length, "", WFM_LABEL_BEFORE);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +WiFiManagerParameter::WiFiManagerParameter(const char *id, const char *label, const char *defaultValue, int length, const char *custom) {
 | 
	
		
			
				|  |  | +  init(id, label, defaultValue, length, custom, WFM_LABEL_BEFORE);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +WiFiManagerParameter::WiFiManagerParameter(const char *id, const char *label, const char *defaultValue, int length, const char *custom, int labelPlacement) {
 | 
	
		
			
				|  |  | +  init(id, label, defaultValue, length, custom, labelPlacement);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +void WiFiManagerParameter::init(const char *id, const char *label, const char *defaultValue, int length, const char *custom, int labelPlacement) {
 | 
	
		
			
				|  |  | +  _id             = id;
 | 
	
		
			
				|  |  | +  _label          = label;
 | 
	
		
			
				|  |  | +  _labelPlacement = labelPlacement;
 | 
	
		
			
				|  |  | +  _customHTML     = custom;
 | 
	
		
			
				|  |  | +  setValue(defaultValue,length);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +WiFiManagerParameter::~WiFiManagerParameter() {
 | 
	
		
			
				|  |  | +  if (_value != NULL) {
 | 
	
		
			
				|  |  | +    delete[] _value;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  _length=0; // setting length 0, ideally the entire parameter should be removed, or added to wifimanager scope so it follows
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// @note debug is not available in wmparameter class
 | 
	
		
			
				|  |  | +void WiFiManagerParameter::setValue(const char *defaultValue, int length) {
 | 
	
		
			
				|  |  | +  if(!_id){
 | 
	
		
			
				|  |  | +    // Serial.println("cannot set value of this parameter");
 | 
	
		
			
				|  |  | +    return;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  // if(strlen(defaultValue) > length){
 | 
	
		
			
				|  |  | +  //   // Serial.println("defaultValue length mismatch");
 | 
	
		
			
				|  |  | +  //   // return false; //@todo bail 
 | 
	
		
			
				|  |  | +  // }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  _length = length;
 | 
	
		
			
				|  |  | +  _value  = new char[_length + 1]; 
 | 
	
		
			
				|  |  | +  memset(_value, 0, _length + 1); // explicit null
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  if (defaultValue != NULL) {
 | 
	
		
			
				|  |  | +    strncpy(_value, defaultValue, _length);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +const char* WiFiManagerParameter::getValue() {
 | 
	
		
			
				|  |  | +  return _value;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +const char* WiFiManagerParameter::getID() {
 | 
	
		
			
				|  |  | +  return _id;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +const char* WiFiManagerParameter::getPlaceholder() {
 | 
	
		
			
				|  |  | +  return _label;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +const char* WiFiManagerParameter::getLabel() {
 | 
	
		
			
				|  |  | +  return _label;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +int WiFiManagerParameter::getValueLength() {
 | 
	
		
			
				|  |  | +  return _length;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +int WiFiManagerParameter::getLabelPlacement() {
 | 
	
		
			
				|  |  | +  return _labelPlacement;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +const char* WiFiManagerParameter::getCustomHTML() {
 | 
	
		
			
				|  |  | +  return _customHTML;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [addParameter description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} WiFiManagerParameter *p [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +bool WiFiManager::addParameter(WiFiManagerParameter *p) {
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // check param id is valid, unless null
 | 
	
		
			
				|  |  | +  if(p->getID()){
 | 
	
		
			
				|  |  | +    for (size_t i = 0; i < strlen(p->getID()); i++){
 | 
	
		
			
				|  |  | +       if(!(isAlphaNumeric(p->getID()[i])) && !(p->getID()[i]=='_')){
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_ERROR,"[ERROR] parameter IDs can only contain alpha numeric chars");
 | 
	
		
			
				|  |  | +        return false;
 | 
	
		
			
				|  |  | +       }
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // init params if never malloc
 | 
	
		
			
				|  |  | +  if(_params == NULL){
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_DEV,"allocating params bytes:",_max_params * sizeof(WiFiManagerParameter*));        
 | 
	
		
			
				|  |  | +    _params = (WiFiManagerParameter**)malloc(_max_params * sizeof(WiFiManagerParameter*));
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // resize the params array by increment of WIFI_MANAGER_MAX_PARAMS
 | 
	
		
			
				|  |  | +  if(_paramsCount == _max_params){
 | 
	
		
			
				|  |  | +    _max_params += WIFI_MANAGER_MAX_PARAMS;
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_DEV,F("Updated _max_params:"),_max_params);
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_DEV,"re-allocating params bytes:",_max_params * sizeof(WiFiManagerParameter*));    
 | 
	
		
			
				|  |  | +    WiFiManagerParameter** new_params = (WiFiManagerParameter**)realloc(_params, _max_params * sizeof(WiFiManagerParameter*));
 | 
	
		
			
				|  |  | +    // DEBUG_WM(WIFI_MANAGER_MAX_PARAMS);
 | 
	
		
			
				|  |  | +    // DEBUG_WM(_paramsCount);
 | 
	
		
			
				|  |  | +    // DEBUG_WM(_max_params);
 | 
	
		
			
				|  |  | +    if (new_params != NULL) {
 | 
	
		
			
				|  |  | +      _params = new_params;
 | 
	
		
			
				|  |  | +    } else {
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_ERROR,"[ERROR] failed to realloc params, size not increased!");
 | 
	
		
			
				|  |  | +      return false;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  _params[_paramsCount] = p;
 | 
	
		
			
				|  |  | +  _paramsCount++;
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,"Added Parameter:",p->getID());
 | 
	
		
			
				|  |  | +  return true;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [getParameters description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +WiFiManagerParameter** WiFiManager::getParameters() {
 | 
	
		
			
				|  |  | +  return _params;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [getParametersCount description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +int WiFiManager::getParametersCount() {
 | 
	
		
			
				|  |  | +  return _paramsCount;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * --------------------------------------------------------------------------------
 | 
	
		
			
				|  |  | + *  WiFiManager 
 | 
	
		
			
				|  |  | + * --------------------------------------------------------------------------------
 | 
	
		
			
				|  |  | +**/
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// constructors
 | 
	
		
			
				|  |  | +WiFiManager::WiFiManager(Stream& consolePort):_debugPort(consolePort){
 | 
	
		
			
				|  |  | +  WiFiManagerInit();
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +WiFiManager::WiFiManager() {
 | 
	
		
			
				|  |  | +  WiFiManagerInit();  
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +void WiFiManager::WiFiManagerInit(){
 | 
	
		
			
				|  |  | +  setMenu(_menuIdsDefault);
 | 
	
		
			
				|  |  | +  if(_debug && _debugLevel > DEBUG_DEV) debugPlatformInfo();
 | 
	
		
			
				|  |  | +  _max_params = WIFI_MANAGER_MAX_PARAMS;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// destructor
 | 
	
		
			
				|  |  | +WiFiManager::~WiFiManager() {
 | 
	
		
			
				|  |  | +  _end();
 | 
	
		
			
				|  |  | +  // parameters
 | 
	
		
			
				|  |  | +  // @todo below belongs to wifimanagerparameter
 | 
	
		
			
				|  |  | +  if (_params != NULL){
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_DEV,F("freeing allocated params!"));
 | 
	
		
			
				|  |  | +    free(_params);
 | 
	
		
			
				|  |  | +    _params = NULL;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // @todo remove event
 | 
	
		
			
				|  |  | +  // #ifdef ESP32
 | 
	
		
			
				|  |  | +  // WiFi.removeEvent(std::bind(&WiFiManager::WiFiEvent,this));
 | 
	
		
			
				|  |  | +  // #endif
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,F("unloading"));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +void WiFiManager::_begin(){
 | 
	
		
			
				|  |  | +  if(_hasBegun) return;
 | 
	
		
			
				|  |  | +  _hasBegun = true;
 | 
	
		
			
				|  |  | +  _usermode = WiFi.getMode();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  #ifndef ESP32
 | 
	
		
			
				|  |  | +  WiFi.persistent(false); // disable persistent so scannetworks and mode switching do not cause overwrites
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +void WiFiManager::_end(){
 | 
	
		
			
				|  |  | +  _hasBegun = false;
 | 
	
		
			
				|  |  | +  if(_userpersistent) WiFi.persistent(true); // reenable persistent, there is no getter we rely on _userpersistent
 | 
	
		
			
				|  |  | +  // if(_usermode != WIFI_OFF) WiFi.mode(_usermode);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// AUTOCONNECT
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +boolean WiFiManager::autoConnect() {
 | 
	
		
			
				|  |  | +  String ssid = getDefaultAPName();
 | 
	
		
			
				|  |  | +  return autoConnect(ssid.c_str(), NULL);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [autoConnect description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param  {[type]} char const         *apName     [description]
 | 
	
		
			
				|  |  | + * @param  {[type]} char const         *apPassword [description]
 | 
	
		
			
				|  |  | + * @return {[type]}      [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +boolean WiFiManager::autoConnect(char const *apName, char const *apPassword) {
 | 
	
		
			
				|  |  | +  DEBUG_WM(F("AutoConnect"));
 | 
	
		
			
				|  |  | +  _begin();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // attempt to connect using saved settings, on fail fallback to AP config portal
 | 
	
		
			
				|  |  | +  if(!WiFi.enableSTA(true)){
 | 
	
		
			
				|  |  | +    // handle failure mode Brownout detector etc.
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_ERROR,"[FATAL] Unable to enable wifi!");
 | 
	
		
			
				|  |  | +    return false;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  WiFiSetCountry();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  #ifdef ESP32
 | 
	
		
			
				|  |  | +  if(esp32persistent) WiFi.persistent(false); // disable persistent for esp32 after esp_wifi_start or else saves wont work
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  _usermode = WIFI_STA;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // no getter for autoreconnectpolicy before this
 | 
	
		
			
				|  |  | +  // https://github.com/esp8266/Arduino/pull/4359
 | 
	
		
			
				|  |  | +  // so we must force it on else, if not connectimeout then waitforconnectionresult gets stuck endless loop
 | 
	
		
			
				|  |  | +  WiFi_autoReconnect();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // set hostname before stating
 | 
	
		
			
				|  |  | +  if((String)_hostname != ""){
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_VERBOSE,"Setting hostname:",_hostname);
 | 
	
		
			
				|  |  | +    bool res = true;
 | 
	
		
			
				|  |  | +    #ifdef ESP8266
 | 
	
		
			
				|  |  | +      res = WiFi.hostname(_hostname);
 | 
	
		
			
				|  |  | +      #ifdef ESP8266MDNS_H
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_VERBOSE,"Setting MDNS hostname");
 | 
	
		
			
				|  |  | +        if(MDNS.begin(_hostname)){
 | 
	
		
			
				|  |  | +          MDNS.addService("http", "tcp", 80);
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      #endif
 | 
	
		
			
				|  |  | +    #elif defined(ESP32)
 | 
	
		
			
				|  |  | +      // @note hostname must be set after STA_START
 | 
	
		
			
				|  |  | +      delay(200); // do not remove, give time for STA_START
 | 
	
		
			
				|  |  | +      res = WiFi.setHostname(_hostname);
 | 
	
		
			
				|  |  | +      #ifdef ESP32MDNS_H
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_VERBOSE,"Setting MDNS hostname");
 | 
	
		
			
				|  |  | +        if(MDNS.begin(_hostname)){
 | 
	
		
			
				|  |  | +          MDNS.addService("http", "tcp", 80);
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      #endif
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +    
 | 
	
		
			
				|  |  | +    if(!res)DEBUG_WM(DEBUG_ERROR,F("[ERROR] hostname: set failed!"));
 | 
	
		
			
				|  |  | +    
 | 
	
		
			
				|  |  | +    if(WiFi.status() == WL_CONNECTED){
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_VERBOSE,F("reconnecting to set new hostname"));
 | 
	
		
			
				|  |  | +      // WiFi.reconnect(); // This does not reset dhcp
 | 
	
		
			
				|  |  | +      WiFi_Disconnect();
 | 
	
		
			
				|  |  | +      delay(200); // do not remove, need a delay for disconnect to change status()
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // if already connected, or try stored connect 
 | 
	
		
			
				|  |  | +  // @note @todo ESP32 has no autoconnect, so connectwifi will always be called unless user called begin etc before
 | 
	
		
			
				|  |  | +  // @todo check if correct ssid == saved ssid when already connected
 | 
	
		
			
				|  |  | +  bool connected = false;
 | 
	
		
			
				|  |  | +  if (WiFi.status() == WL_CONNECTED){
 | 
	
		
			
				|  |  | +    connected = true;
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("AutoConnect: ESP Already Connected"));
 | 
	
		
			
				|  |  | +    setSTAConfig();
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(connected || connectWifi("", "") == WL_CONNECTED){
 | 
	
		
			
				|  |  | +    //connected
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("AutoConnect: SUCCESS"));
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("STA IP Address:"),WiFi.localIP());
 | 
	
		
			
				|  |  | +    _lastconxresult = WL_CONNECTED;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    if((String)_hostname != ""){
 | 
	
		
			
				|  |  | +      #ifdef ESP8266
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_DEV,"hostname: STA",WiFi.hostname());
 | 
	
		
			
				|  |  | +      #elif defined(ESP32)
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_DEV,"hostname: STA",WiFi.getHostname());
 | 
	
		
			
				|  |  | +      #endif
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    return true;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // possibly skip the config portal
 | 
	
		
			
				|  |  | +  if (!_enableConfigPortal) {
 | 
	
		
			
				|  |  | +    return false;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM(F("AutoConnect: FAILED"));
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // not connected start configportal
 | 
	
		
			
				|  |  | +  return startConfigPortal(apName, apPassword);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// CONFIG PORTAL
 | 
	
		
			
				|  |  | +bool WiFiManager::startAP(){
 | 
	
		
			
				|  |  | +  bool ret = true;
 | 
	
		
			
				|  |  | +  DEBUG_WM(F("StartAP with SSID: "),_apName);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  #ifdef ESP8266
 | 
	
		
			
				|  |  | +    // @bug workaround for bug #4372 https://github.com/esp8266/Arduino/issues/4372
 | 
	
		
			
				|  |  | +    if(!WiFi.enableAP(true)) {
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_ERROR,"[ERROR] enableAP failed!");
 | 
	
		
			
				|  |  | +      return false;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    delay(500); // workaround delay
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // setup optional soft AP static ip config
 | 
	
		
			
				|  |  | +  if (_ap_static_ip) {
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("Custom AP IP/GW/Subnet:"));
 | 
	
		
			
				|  |  | +    if(!WiFi.softAPConfig(_ap_static_ip, _ap_static_gw, _ap_static_sn)){
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_ERROR,"[ERROR] softAPConfig failed!");
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  //@todo add callback here if needed to modify ap but cannot use setAPStaticIPConfig
 | 
	
		
			
				|  |  | +  //@todo rework wifi channelsync as it will work unpredictably when not connected in sta
 | 
	
		
			
				|  |  | + 
 | 
	
		
			
				|  |  | +  int32_t channel = 0;
 | 
	
		
			
				|  |  | +  if(_channelSync) channel = WiFi.channel();
 | 
	
		
			
				|  |  | +  else channel = _apChannel;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(channel>0){
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_VERBOSE,"Starting AP on channel:",channel);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // start soft AP with password or anonymous
 | 
	
		
			
				|  |  | +  // default channel is 1 here and in esplib, @todo just change to default remove conditionals
 | 
	
		
			
				|  |  | +  if (_apPassword != "") {
 | 
	
		
			
				|  |  | +    if(channel>0){
 | 
	
		
			
				|  |  | +      ret = WiFi.softAP(_apName.c_str(), _apPassword.c_str(),channel,_apHidden);
 | 
	
		
			
				|  |  | +    }  
 | 
	
		
			
				|  |  | +    else{
 | 
	
		
			
				|  |  | +      ret = WiFi.softAP(_apName.c_str(), _apPassword.c_str(),1,_apHidden);//password option
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  } else {
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_VERBOSE,F("AP has anonymous access!"));    
 | 
	
		
			
				|  |  | +    if(channel>0){
 | 
	
		
			
				|  |  | +      ret = WiFi.softAP(_apName.c_str(),"",channel,_apHidden);
 | 
	
		
			
				|  |  | +    }  
 | 
	
		
			
				|  |  | +    else{
 | 
	
		
			
				|  |  | +      ret = WiFi.softAP(_apName.c_str(),"",1,_apHidden);
 | 
	
		
			
				|  |  | +    }  
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(_debugLevel >= DEBUG_DEV) debugSoftAPConfig();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(!ret) DEBUG_WM(DEBUG_ERROR,"[ERROR] There was a problem starting the AP");
 | 
	
		
			
				|  |  | +  // @todo add softAP retry here
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  delay(500); // slight delay to make sure we get an AP IP
 | 
	
		
			
				|  |  | +  DEBUG_WM(F("AP IP address:"),WiFi.softAPIP());
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // set ap hostname
 | 
	
		
			
				|  |  | +  #ifdef ESP32
 | 
	
		
			
				|  |  | +    if(ret && (String)_hostname != ""){
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_VERBOSE,"setting softAP Hostname:",_hostname);
 | 
	
		
			
				|  |  | +      bool res =  WiFi.softAPsetHostname(_hostname);
 | 
	
		
			
				|  |  | +      if(!res)DEBUG_WM(DEBUG_ERROR,F("[ERROR] hostname: AP set failed!"));
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_DEV,F("hostname: AP"),WiFi.softAPgetHostname());
 | 
	
		
			
				|  |  | +   }
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  return ret;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [startWebPortal description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @return {[type]} [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::startWebPortal() {
 | 
	
		
			
				|  |  | +  if(configPortalActive || webPortalActive) return;
 | 
	
		
			
				|  |  | +  setupConfigPortal();
 | 
	
		
			
				|  |  | +  webPortalActive = true;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [stopWebPortal description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @return {[type]} [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::stopWebPortal() {
 | 
	
		
			
				|  |  | +  if(!configPortalActive && !webPortalActive) return;
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("Stopping Web Portal"));  
 | 
	
		
			
				|  |  | +  webPortalActive = false;
 | 
	
		
			
				|  |  | +  shutdownConfigPortal();
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +boolean WiFiManager::configPortalHasTimeout(){
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    if(_configPortalTimeout == 0 || (_apClientCheck && (WiFi_softap_num_stations() > 0))){
 | 
	
		
			
				|  |  | +      if(millis() - timer > 30000){
 | 
	
		
			
				|  |  | +        timer = millis();
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_VERBOSE,"NUM CLIENTS: " + (String)WiFi_softap_num_stations());
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      _configPortalStart = millis(); // kludge, bump configportal start time to skew timeouts
 | 
	
		
			
				|  |  | +      return false;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    // handle timeout
 | 
	
		
			
				|  |  | +    if(_webClientCheck && (_webPortalAccessed>_configPortalStart)>0) _configPortalStart = _webPortalAccessed;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    if(millis() > _configPortalStart + _configPortalTimeout){
 | 
	
		
			
				|  |  | +      DEBUG_WM(F("config portal has timed out"));
 | 
	
		
			
				|  |  | +      return true;
 | 
	
		
			
				|  |  | +    } else if(_debugLevel > 0) {
 | 
	
		
			
				|  |  | +      // log timeout
 | 
	
		
			
				|  |  | +      if(_debug){
 | 
	
		
			
				|  |  | +        uint16_t logintvl = 30000; // how often to emit timeing out counter logging
 | 
	
		
			
				|  |  | +        if((millis() - timer) > logintvl){
 | 
	
		
			
				|  |  | +          timer = millis();
 | 
	
		
			
				|  |  | +          DEBUG_WM(DEBUG_VERBOSE,F("Portal Timeout In"),(String)((_configPortalStart + _configPortalTimeout-millis())/1000) + (String)F(" seconds"));
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    return false;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +void WiFiManager::setupConfigPortal() {
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM(F("Starting Web Portal"));
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // setup dns and web servers
 | 
	
		
			
				|  |  | +  dnsServer.reset(new DNSServer());
 | 
	
		
			
				|  |  | +  server.reset(new WM_WebServer(80));
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  /* Setup the DNS server redirecting all the domains to the apIP */
 | 
	
		
			
				|  |  | +  dnsServer->setErrorReplyCode(DNSReplyCode::NoError);
 | 
	
		
			
				|  |  | +  // DEBUG_WM("dns server started port: ",DNS_PORT);
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,"dns server started with ip: ",WiFi.softAPIP());
 | 
	
		
			
				|  |  | +  dnsServer->start(DNS_PORT, F("*"), WiFi.softAPIP());
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // @todo new callback, webserver started, callback cannot override handlers, but can grab them first
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if ( _webservercallback != NULL) {
 | 
	
		
			
				|  |  | +    _webservercallback();
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  /* Setup httpd callbacks, web pages: root, wifi config pages, SO captive portal detectors and not found. */
 | 
	
		
			
				|  |  | +  server->on(String(FPSTR(R_root)).c_str(),       std::bind(&WiFiManager::handleRoot, this));
 | 
	
		
			
				|  |  | +  server->on(String(FPSTR(R_wifi)).c_str(),       std::bind(&WiFiManager::handleWifi, this, true));
 | 
	
		
			
				|  |  | +  server->on(String(FPSTR(R_wifinoscan)).c_str(), std::bind(&WiFiManager::handleWifi, this, false));
 | 
	
		
			
				|  |  | +  server->on(String(FPSTR(R_wifisave)).c_str(),   std::bind(&WiFiManager::handleWifiSave, this));
 | 
	
		
			
				|  |  | +  server->on(String(FPSTR(R_info)).c_str(),       std::bind(&WiFiManager::handleInfo, this));
 | 
	
		
			
				|  |  | +  server->on(String(FPSTR(R_param)).c_str(),      std::bind(&WiFiManager::handleParam, this));
 | 
	
		
			
				|  |  | +  server->on(String(FPSTR(R_paramsave)).c_str(),  std::bind(&WiFiManager::handleParamSave, this));
 | 
	
		
			
				|  |  | +  server->on(String(FPSTR(R_restart)).c_str(),    std::bind(&WiFiManager::handleReset, this));
 | 
	
		
			
				|  |  | +  server->on(String(FPSTR(R_exit)).c_str(),       std::bind(&WiFiManager::handleExit, this));
 | 
	
		
			
				|  |  | +  server->on(String(FPSTR(R_close)).c_str(),      std::bind(&WiFiManager::handleClose, this));
 | 
	
		
			
				|  |  | +  server->on(String(FPSTR(R_erase)).c_str(),      std::bind(&WiFiManager::handleErase, this, false));
 | 
	
		
			
				|  |  | +  server->on(String(FPSTR(R_status)).c_str(),     std::bind(&WiFiManager::handleWiFiStatus, this));
 | 
	
		
			
				|  |  | +  server->onNotFound (std::bind(&WiFiManager::handleNotFound, this));
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  server->begin(); // Web server start
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("HTTP server started"));
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(_preloadwifiscan) WiFi_scanNetworks(true,true); // preload wifiscan , async
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +boolean WiFiManager::startConfigPortal() {
 | 
	
		
			
				|  |  | +  String ssid = getDefaultAPName();
 | 
	
		
			
				|  |  | +  return startConfigPortal(ssid.c_str(), NULL);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [startConfigPortal description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param  {[type]} char const         *apName     [description]
 | 
	
		
			
				|  |  | + * @param  {[type]} char const         *apPassword [description]
 | 
	
		
			
				|  |  | + * @return {[type]}      [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +boolean  WiFiManager::startConfigPortal(char const *apName, char const *apPassword) {
 | 
	
		
			
				|  |  | +  _begin();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  //setup AP
 | 
	
		
			
				|  |  | +  _apName     = apName; // @todo check valid apname ?
 | 
	
		
			
				|  |  | +  _apPassword = apPassword;
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("Starting Config Portal"));
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(_apName == "") _apName = getDefaultAPName();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(!validApPassword()) return false;
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  // HANDLE issues with STA connections, shutdown sta if not connected, or else this will hang channel scanning and softap will not respond
 | 
	
		
			
				|  |  | +  // @todo sometimes still cannot connect to AP for no known reason, no events in log either
 | 
	
		
			
				|  |  | +  if(_disableSTA || (!WiFi.isConnected() && _disableSTAConn)){
 | 
	
		
			
				|  |  | +    // this fixes most ap problems, however, simply doing mode(WIFI_AP) does not work if sta connection is hanging, must `wifi_station_disconnect` 
 | 
	
		
			
				|  |  | +    WiFi_Disconnect();
 | 
	
		
			
				|  |  | +    WiFi_enableSTA(false);
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_VERBOSE,F("Disabling STA"));
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else {
 | 
	
		
			
				|  |  | +    // @todo even if sta is connected, it is possible that softap connections will fail, IOS says "invalid password", windows says "cannot connect to this network" researching
 | 
	
		
			
				|  |  | +    WiFi_enableSTA(true);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // init configportal globals to known states
 | 
	
		
			
				|  |  | +  configPortalActive = true;
 | 
	
		
			
				|  |  | +  bool result = connect = abort = false; // loop flags, connect true success, abort true break
 | 
	
		
			
				|  |  | +  uint8_t state;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  _configPortalStart = millis();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // start access point
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("Enabling AP"));
 | 
	
		
			
				|  |  | +  startAP();
 | 
	
		
			
				|  |  | +  WiFiSetCountry();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // do AP callback if set
 | 
	
		
			
				|  |  | +  if ( _apcallback != NULL) {
 | 
	
		
			
				|  |  | +    _apcallback(this);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // init configportal
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,F("setupConfigPortal"));
 | 
	
		
			
				|  |  | +  setupConfigPortal();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(!_configPortalIsBlocking){
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_VERBOSE,F("Config Portal Running, non blocking/processing"));
 | 
	
		
			
				|  |  | +    return result;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("Config Portal Running, blocking, waiting for clients..."));
 | 
	
		
			
				|  |  | +  // blocking loop waiting for config
 | 
	
		
			
				|  |  | +  while(1){
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    // if timed out or abort, break
 | 
	
		
			
				|  |  | +    if(configPortalHasTimeout() || abort){
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_DEV,F("configportal abort"));
 | 
	
		
			
				|  |  | +      shutdownConfigPortal();
 | 
	
		
			
				|  |  | +      result = abort ? portalAbortResult : portalTimeoutResult; // false, false
 | 
	
		
			
				|  |  | +      break;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    state = processConfigPortal();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    // status change, break
 | 
	
		
			
				|  |  | +    if(state != WL_IDLE_STATUS){
 | 
	
		
			
				|  |  | +        result = (state == WL_CONNECTED); // true if connected
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    yield(); // watchdog
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_NOTIFY,F("config portal exiting"));
 | 
	
		
			
				|  |  | +  return result;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [process description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @return {[type]} [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +boolean WiFiManager::process(){
 | 
	
		
			
				|  |  | +    if(webPortalActive || (configPortalActive && !_configPortalIsBlocking)){
 | 
	
		
			
				|  |  | +        uint8_t state = processConfigPortal();
 | 
	
		
			
				|  |  | +        return state == WL_CONNECTED;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    return false;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +//using esp enums returns for now, should be fine
 | 
	
		
			
				|  |  | +uint8_t WiFiManager::processConfigPortal(){
 | 
	
		
			
				|  |  | +    //DNS handler
 | 
	
		
			
				|  |  | +    dnsServer->processNextRequest();
 | 
	
		
			
				|  |  | +    //HTTP handler
 | 
	
		
			
				|  |  | +    server->handleClient();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    // Waiting for save...
 | 
	
		
			
				|  |  | +    if(connect) {
 | 
	
		
			
				|  |  | +      connect = false;
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_VERBOSE,F("process connect"));
 | 
	
		
			
				|  |  | +      if(_enableCaptivePortal) delay(_cpclosedelay); // keeps the captiveportal from closing to fast.
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      // skip wifi if no ssid
 | 
	
		
			
				|  |  | +      if(_ssid == ""){
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_VERBOSE,F("No ssid, skipping wifi save"));
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      else{
 | 
	
		
			
				|  |  | +        // attempt sta connection to submitted _ssid, _pass
 | 
	
		
			
				|  |  | +        if (connectWifi(_ssid, _pass) == WL_CONNECTED) {
 | 
	
		
			
				|  |  | +          
 | 
	
		
			
				|  |  | +          DEBUG_WM(F("Connect to new AP [SUCCESS]"));
 | 
	
		
			
				|  |  | +          DEBUG_WM(F("Got IP Address:"));
 | 
	
		
			
				|  |  | +          DEBUG_WM(WiFi.localIP());
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +          if ( _savewificallback != NULL) {
 | 
	
		
			
				|  |  | +            _savewificallback();
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          shutdownConfigPortal();
 | 
	
		
			
				|  |  | +          return WL_CONNECTED; // CONNECT SUCCESS
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_ERROR,F("[ERROR] Connect to new AP Failed"));
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | + 
 | 
	
		
			
				|  |  | +      if (_shouldBreakAfterConfig) {
 | 
	
		
			
				|  |  | +        // do save callback
 | 
	
		
			
				|  |  | +        // @todo this is more of an exiting callback than a save, clarify when this should actually occur
 | 
	
		
			
				|  |  | +        // confirm or verify data was saved to make this more accurate callback
 | 
	
		
			
				|  |  | +        if ( _savewificallback != NULL) {
 | 
	
		
			
				|  |  | +          _savewificallback();
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        shutdownConfigPortal();
 | 
	
		
			
				|  |  | +        return WL_CONNECT_FAILED; // CONNECT FAIL
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      else{
 | 
	
		
			
				|  |  | +        // clear save strings
 | 
	
		
			
				|  |  | +        _ssid = "";
 | 
	
		
			
				|  |  | +        _pass = "";
 | 
	
		
			
				|  |  | +        // if connect fails, turn sta off to stabilize AP
 | 
	
		
			
				|  |  | +        WiFi_Disconnect();
 | 
	
		
			
				|  |  | +        WiFi_enableSTA(false);
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_VERBOSE,F("Disabling STA"));
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    return WL_IDLE_STATUS;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [shutdownConfigPortal description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @return bool success (softapdisconnect)
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +bool WiFiManager::shutdownConfigPortal(){
 | 
	
		
			
				|  |  | +  if(webPortalActive) return false;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  //DNS handler
 | 
	
		
			
				|  |  | +  dnsServer->processNextRequest();
 | 
	
		
			
				|  |  | +  //HTTP handler
 | 
	
		
			
				|  |  | +  server->handleClient();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // @todo what is the proper way to shutdown and free the server up
 | 
	
		
			
				|  |  | +  server->stop();
 | 
	
		
			
				|  |  | +  server.reset();
 | 
	
		
			
				|  |  | +  dnsServer->stop(); //  free heap ?
 | 
	
		
			
				|  |  | +  dnsServer.reset();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  WiFi.scanDelete(); // free wifi scan results
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(!configPortalActive) return false;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // turn off AP
 | 
	
		
			
				|  |  | +  // @todo bug workaround
 | 
	
		
			
				|  |  | +  // https://github.com/esp8266/Arduino/issues/3793
 | 
	
		
			
				|  |  | +  // [APdisconnect] set_config failed! *WM: disconnect configportal - softAPdisconnect failed
 | 
	
		
			
				|  |  | +  // still no way to reproduce reliably
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("disconnect configportal"));
 | 
	
		
			
				|  |  | +  bool ret = false;
 | 
	
		
			
				|  |  | +  ret = WiFi.softAPdisconnect(false);
 | 
	
		
			
				|  |  | +  if(!ret)DEBUG_WM(DEBUG_ERROR,F("[ERROR] disconnect configportal - softAPdisconnect FAILED"));
 | 
	
		
			
				|  |  | +  delay(1000);
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,"restoring usermode",getModeString(_usermode));
 | 
	
		
			
				|  |  | +  WiFi_Mode(_usermode); // restore users wifi mode, BUG https://github.com/esp8266/Arduino/issues/4372
 | 
	
		
			
				|  |  | +  if(WiFi.status()==WL_IDLE_STATUS){
 | 
	
		
			
				|  |  | +    WiFi.reconnect(); // restart wifi since we disconnected it in startconfigportal
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_VERBOSE,"WiFi Reconnect, was idle");
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,"wifi status:",getWLStatusString(WiFi.status()));
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,"wifi mode:",getModeString(WiFi.getMode()));
 | 
	
		
			
				|  |  | +  configPortalActive = false;
 | 
	
		
			
				|  |  | +  _end();
 | 
	
		
			
				|  |  | +  return ret;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// @todo refactor this up into seperate functions
 | 
	
		
			
				|  |  | +// one for connecting to flash , one for new client
 | 
	
		
			
				|  |  | +// clean up, flow is convoluted, and causes bugs
 | 
	
		
			
				|  |  | +uint8_t WiFiManager::connectWifi(String ssid, String pass) {
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("Connecting as wifi client..."));
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  uint8_t connRes = (uint8_t)WL_NO_SSID_AVAIL;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  setSTAConfig();
 | 
	
		
			
				|  |  | +  //@todo catch failures in set_config
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  // make sure sta is on before `begin` so it does not call enablesta->mode while persistent is ON ( which would save WM AP state to eeprom !)
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  if(_cleanConnect) WiFi_Disconnect(); // disconnect before begin, in case anything is hung, this causes a 2 seconds delay for connect
 | 
	
		
			
				|  |  | +  // @todo find out what status is when this is needed, can we detect it and handle it, say in between states or idle_status
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  // if ssid argument provided connect to that
 | 
	
		
			
				|  |  | +  if (ssid != "") {
 | 
	
		
			
				|  |  | +    wifiConnectNew(ssid,pass);
 | 
	
		
			
				|  |  | +    if(_saveTimeout > 0){
 | 
	
		
			
				|  |  | +      connRes = waitForConnectResult(_saveTimeout); // use default save timeout for saves to prevent bugs in esp->waitforconnectresult loop
 | 
	
		
			
				|  |  | +    }  
 | 
	
		
			
				|  |  | +    else {
 | 
	
		
			
				|  |  | +       connRes = waitForConnectResult(0);
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else {
 | 
	
		
			
				|  |  | +    // connect using saved ssid if there is one
 | 
	
		
			
				|  |  | +    if (WiFi_hasAutoConnect()) {
 | 
	
		
			
				|  |  | +      wifiConnectDefault();
 | 
	
		
			
				|  |  | +      connRes = waitForConnectResult();
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    else {
 | 
	
		
			
				|  |  | +      DEBUG_WM(F("No saved credentials, skipping wifi"));
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("Connection result:"),getWLStatusString(connRes));
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// WPS enabled? https://github.com/esp8266/Arduino/pull/4889
 | 
	
		
			
				|  |  | +#ifdef NO_EXTRA_4K_HEAP
 | 
	
		
			
				|  |  | +  // do WPS, if WPS options enabled and not connected and no password was supplied
 | 
	
		
			
				|  |  | +  // @todo this seems like wrong place for this, is it a fallback or option?
 | 
	
		
			
				|  |  | +  if (_tryWPS && connRes != WL_CONNECTED && pass == "") {
 | 
	
		
			
				|  |  | +    startWPS();
 | 
	
		
			
				|  |  | +    // should be connected at the end of WPS
 | 
	
		
			
				|  |  | +    connRes = waitForConnectResult();
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +#endif
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(connRes != WL_SCAN_COMPLETED){
 | 
	
		
			
				|  |  | +    updateConxResult(connRes);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  return connRes;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * connect to a new wifi ap
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @param  String ssid 
 | 
	
		
			
				|  |  | + * @param  String pass 
 | 
	
		
			
				|  |  | + * @return bool success
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +bool WiFiManager::wifiConnectNew(String ssid, String pass){
 | 
	
		
			
				|  |  | +  bool ret = false;
 | 
	
		
			
				|  |  | +  DEBUG_WM(F("CONNECTED:"),WiFi.status() == WL_CONNECTED);
 | 
	
		
			
				|  |  | +  DEBUG_WM(F("Connecting to NEW AP:"),ssid);
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,F("Using Password:"),pass);
 | 
	
		
			
				|  |  | +  WiFi_enableSTA(true,storeSTAmode); // storeSTAmode will also toggle STA on in default opmode (persistent) if true (default)
 | 
	
		
			
				|  |  | +  WiFi.persistent(true);
 | 
	
		
			
				|  |  | +  ret = WiFi.begin(ssid.c_str(), pass.c_str());
 | 
	
		
			
				|  |  | +  WiFi.persistent(false);
 | 
	
		
			
				|  |  | +  if(!ret) DEBUG_WM(DEBUG_ERROR,"[ERROR] wifi begin failed");
 | 
	
		
			
				|  |  | +  return ret;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * connect to stored wifi
 | 
	
		
			
				|  |  | + * @since dev
 | 
	
		
			
				|  |  | + * @return bool success
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +bool WiFiManager::wifiConnectDefault(){
 | 
	
		
			
				|  |  | +  bool ret = false;
 | 
	
		
			
				|  |  | +  DEBUG_WM(F("Connecting to SAVED AP:"),WiFi_SSID(true));
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,F("Using Password:"),WiFi_psk(true));
 | 
	
		
			
				|  |  | +  ret = WiFi_enableSTA(true,storeSTAmode);
 | 
	
		
			
				|  |  | +  if(!ret) DEBUG_WM(DEBUG_ERROR,"[ERROR] wifi enableSta failed");
 | 
	
		
			
				|  |  | +  ret = WiFi.begin();
 | 
	
		
			
				|  |  | +  if(!ret) DEBUG_WM(DEBUG_ERROR,"[ERROR] wifi begin failed");
 | 
	
		
			
				|  |  | +  return ret;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * set sta config if set
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @return bool success
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +bool WiFiManager::setSTAConfig(){
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,F("STA static IP:"),_sta_static_ip);  
 | 
	
		
			
				|  |  | +  bool ret = true;
 | 
	
		
			
				|  |  | +  if (_sta_static_ip) {
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_VERBOSE,F("Custom static IP/GW/Subnet/DNS"));
 | 
	
		
			
				|  |  | +    if(_sta_static_dns) {
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_VERBOSE,F("Custom static DNS"));
 | 
	
		
			
				|  |  | +      ret = WiFi.config(_sta_static_ip, _sta_static_gw, _sta_static_sn, _sta_static_dns);
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    else {
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_VERBOSE,F("Custom STA IP/GW/Subnet"));
 | 
	
		
			
				|  |  | +      ret = WiFi.config(_sta_static_ip, _sta_static_gw, _sta_static_sn);
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    if(!ret) DEBUG_WM(DEBUG_ERROR,"[ERROR] wifi config failed");
 | 
	
		
			
				|  |  | +    else DEBUG_WM(F("STA IP set:"),WiFi.localIP());
 | 
	
		
			
				|  |  | +  } else {
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_VERBOSE,F("setSTAConfig static ip not set, skipping"));
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return ret;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// @todo change to getLastFailureReason and do not touch conxresult
 | 
	
		
			
				|  |  | +void WiFiManager::updateConxResult(uint8_t status){
 | 
	
		
			
				|  |  | +  // hack in wrong password detection
 | 
	
		
			
				|  |  | +  _lastconxresult = status;
 | 
	
		
			
				|  |  | +    #ifdef ESP8266
 | 
	
		
			
				|  |  | +      if(_lastconxresult == WL_CONNECT_FAILED){
 | 
	
		
			
				|  |  | +        if(wifi_station_get_connect_status() == STATION_WRONG_PASSWORD){
 | 
	
		
			
				|  |  | +          _lastconxresult = WL_STATION_WRONG_PASSWORD;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    #elif defined(ESP32)
 | 
	
		
			
				|  |  | +      // if(_lastconxresult == WL_CONNECT_FAILED){
 | 
	
		
			
				|  |  | +      if(_lastconxresult == WL_CONNECT_FAILED || _lastconxresult == WL_DISCONNECTED){
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_DEV,"lastconxresulttmp:",getWLStatusString(_lastconxresulttmp));            
 | 
	
		
			
				|  |  | +        if(_lastconxresulttmp != WL_IDLE_STATUS){
 | 
	
		
			
				|  |  | +          _lastconxresult    = _lastconxresulttmp;
 | 
	
		
			
				|  |  | +          // _lastconxresulttmp = WL_IDLE_STATUS;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_DEV,"lastconxresult:",getWLStatusString(_lastconxresult));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | + 
 | 
	
		
			
				|  |  | +uint8_t WiFiManager::waitForConnectResult() {
 | 
	
		
			
				|  |  | +  if(_connectTimeout > 0) DEBUG_WM(DEBUG_VERBOSE,_connectTimeout,F("ms connectTimeout set")); 
 | 
	
		
			
				|  |  | +  return waitForConnectResult(_connectTimeout);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * waitForConnectResult
 | 
	
		
			
				|  |  | + * @param  uint16_t timeout  in seconds
 | 
	
		
			
				|  |  | + * @return uint8_t  WL Status
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +uint8_t WiFiManager::waitForConnectResult(uint16_t timeout) {
 | 
	
		
			
				|  |  | +  if (timeout == 0){
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("connectTimeout not set, ESP waitForConnectResult..."));
 | 
	
		
			
				|  |  | +    return WiFi.waitForConnectResult();
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  unsigned long timeoutmillis = millis() + timeout;
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,timeout,F("ms timeout, waiting for connect..."));
 | 
	
		
			
				|  |  | +  uint8_t status = WiFi.status();
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  while(millis() < timeoutmillis) {
 | 
	
		
			
				|  |  | +    status = WiFi.status();
 | 
	
		
			
				|  |  | +    // @todo detect additional states, connect happens, then dhcp then get ip, there is some delay here, make sure not to timeout if waiting on IP
 | 
	
		
			
				|  |  | +    if (status == WL_CONNECTED || status == WL_CONNECT_FAILED) {
 | 
	
		
			
				|  |  | +      return status;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    DEBUG_WM (DEBUG_VERBOSE,F("."));
 | 
	
		
			
				|  |  | +    delay(100);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return status;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// WPS enabled? https://github.com/esp8266/Arduino/pull/4889
 | 
	
		
			
				|  |  | +#ifdef NO_EXTRA_4K_HEAP
 | 
	
		
			
				|  |  | +void WiFiManager::startWPS() {
 | 
	
		
			
				|  |  | +  DEBUG_WM(F("START WPS"));
 | 
	
		
			
				|  |  | +  #ifdef ESP8266  
 | 
	
		
			
				|  |  | +    WiFi.beginWPSConfig();
 | 
	
		
			
				|  |  | +  #else
 | 
	
		
			
				|  |  | +    // @todo
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +  DEBUG_WM(F("END WPS"));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +#endif
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +String WiFiManager::getHTTPHead(String title){
 | 
	
		
			
				|  |  | +  String page;
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_HEAD_START);
 | 
	
		
			
				|  |  | +  page.replace(FPSTR(T_v), title);
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_SCRIPT);
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_STYLE);
 | 
	
		
			
				|  |  | +  page += _customHeadElement;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(_bodyClass != ""){
 | 
	
		
			
				|  |  | +    String p = FPSTR(HTTP_HEAD_END);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_c), _bodyClass); // add class str
 | 
	
		
			
				|  |  | +    page += p;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else {
 | 
	
		
			
				|  |  | +    page += FPSTR(HTTP_HEAD_END);
 | 
	
		
			
				|  |  | +  } 
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  return page;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/** 
 | 
	
		
			
				|  |  | + * HTTPD handler for page requests
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::handleRequest() {
 | 
	
		
			
				|  |  | +  _webPortalAccessed = millis();
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/** 
 | 
	
		
			
				|  |  | + * HTTPD CALLBACK root or redirect to captive portal
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::handleRoot() {
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("<- HTTP Root"));
 | 
	
		
			
				|  |  | +  if (captivePortal()) return; // If captive portal redirect instead of displaying the page
 | 
	
		
			
				|  |  | +  handleRequest();
 | 
	
		
			
				|  |  | +  String page = getHTTPHead(FPSTR(S_options)); // @token options
 | 
	
		
			
				|  |  | +  String str  = FPSTR(HTTP_ROOT_MAIN);
 | 
	
		
			
				|  |  | +  str.replace(FPSTR(T_v),configPortalActive ? _apName : WiFi.localIP().toString()); // use ip if ap is not active for heading
 | 
	
		
			
				|  |  | +  page += str;
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_PORTAL_OPTIONS);
 | 
	
		
			
				|  |  | +  page += getMenuOut();
 | 
	
		
			
				|  |  | +  reportStatus(page);
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_END);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  server->sendHeader(FPSTR(HTTP_HEAD_CL), String(page.length()));
 | 
	
		
			
				|  |  | +  server->send(200, FPSTR(HTTP_HEAD_CT), page);
 | 
	
		
			
				|  |  | +  // server->close(); // testing reliability fix for content length mismatches during mutiple flood hits  WiFi_scanNetworks(); // preload wifiscan 
 | 
	
		
			
				|  |  | +  if(_preloadwifiscan) WiFi_scanNetworks(_scancachetime,true); // preload wifiscan throttled, async
 | 
	
		
			
				|  |  | +  // @todo buggy, captive portals make a query on every page load, causing this to run every time in addition to the real page load
 | 
	
		
			
				|  |  | +  // I dont understand why, when you are already in the captive portal, I guess they want to know that its still up and not done or gone
 | 
	
		
			
				|  |  | +  // if we can detect these and ignore them that would be great, since they come from the captive portal redirect maybe there is a refferer
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * HTTPD CALLBACK Wifi config page handler
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::handleWifi(boolean scan) {
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("<- HTTP Wifi"));
 | 
	
		
			
				|  |  | +  handleRequest();
 | 
	
		
			
				|  |  | +  String page = getHTTPHead(FPSTR(S_titlewifi)); // @token titlewifi
 | 
	
		
			
				|  |  | +  if (scan) {
 | 
	
		
			
				|  |  | +    // DEBUG_WM(DEBUG_DEV,"refresh flag:",server->hasArg(F("refresh")));
 | 
	
		
			
				|  |  | +    WiFi_scanNetworks(server->hasArg(F("refresh")),false); //wifiscan, force if arg refresh
 | 
	
		
			
				|  |  | +    page += getScanItemOut();
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  String pitem = "";
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  pitem = FPSTR(HTTP_FORM_START);
 | 
	
		
			
				|  |  | +  pitem.replace(FPSTR(T_v), F("wifisave")); // set form action
 | 
	
		
			
				|  |  | +  page += pitem;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  pitem = FPSTR(HTTP_FORM_WIFI);
 | 
	
		
			
				|  |  | +  pitem.replace(FPSTR(T_v), WiFi_SSID());
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(_showPassword){
 | 
	
		
			
				|  |  | +    pitem.replace(FPSTR(T_p), WiFi_psk());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else {
 | 
	
		
			
				|  |  | +    pitem.replace(FPSTR(T_p),FPSTR(S_passph));    
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  page += pitem;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  page += getStaticOut();
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_FORM_WIFI_END);
 | 
	
		
			
				|  |  | +  if(_paramsInWifi && _paramsCount>0){
 | 
	
		
			
				|  |  | +    page += FPSTR(HTTP_FORM_PARAM_HEAD);
 | 
	
		
			
				|  |  | +    page += getParamOut();
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_FORM_END);
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_SCAN_LINK);
 | 
	
		
			
				|  |  | +  reportStatus(page);
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_END);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  server->sendHeader(FPSTR(HTTP_HEAD_CL), String(page.length()));
 | 
	
		
			
				|  |  | +  server->send(200, FPSTR(HTTP_HEAD_CT), page);
 | 
	
		
			
				|  |  | +  // server->close(); // testing reliability fix for content length mismatches during mutiple flood hits
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,F("Sent config page"));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * HTTPD CALLBACK Wifi param page handler
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::handleParam(){
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("<- HTTP Param"));
 | 
	
		
			
				|  |  | +  handleRequest();
 | 
	
		
			
				|  |  | +  String page = getHTTPHead(FPSTR(S_titleparam)); // @token titlewifi
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  String pitem = "";
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  pitem = FPSTR(HTTP_FORM_START);
 | 
	
		
			
				|  |  | +  pitem.replace(FPSTR(T_v), F("paramsave"));
 | 
	
		
			
				|  |  | +  page += pitem;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  page += getParamOut();
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_FORM_END);
 | 
	
		
			
				|  |  | +  reportStatus(page);
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_END);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  server->sendHeader(FPSTR(HTTP_HEAD_CL), String(page.length()));
 | 
	
		
			
				|  |  | +  server->send(200, FPSTR(HTTP_HEAD_CT), page);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,F("Sent param page"));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +String WiFiManager::getMenuOut(){
 | 
	
		
			
				|  |  | +  String page;  
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  for(auto menuId :_menuIds ){
 | 
	
		
			
				|  |  | +    if(((String)menuId == "param") && (_paramsCount == 0)) continue; // no params set, omit params from menu, @todo this may be undesired by someone
 | 
	
		
			
				|  |  | +    page += HTTP_PORTAL_MENU[menuId];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  return page;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// // is it possible in softap mode to detect aps without scanning
 | 
	
		
			
				|  |  | +// bool WiFiManager::WiFi_scanNetworksForAP(bool force){
 | 
	
		
			
				|  |  | +//   WiFi_scanNetworks(force);
 | 
	
		
			
				|  |  | +// }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +void WiFiManager::WiFi_scanComplete(int networksFound){
 | 
	
		
			
				|  |  | +  _lastscan = millis();
 | 
	
		
			
				|  |  | +  _numNetworks = networksFound;
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("WiFi Scan ASYNC completed"), "in "+(String)(_lastscan - _startscan)+" ms");  
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("WiFi Scan ASYNC found:"),_numNetworks);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +bool WiFiManager::WiFi_scanNetworks(){
 | 
	
		
			
				|  |  | +  return WiFi_scanNetworks(false,false);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +bool WiFiManager::WiFi_scanNetworks(unsigned int cachetime,bool async){
 | 
	
		
			
				|  |  | +    return WiFi_scanNetworks(millis()-_lastscan > cachetime,async);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +bool WiFiManager::WiFi_scanNetworks(unsigned int cachetime){
 | 
	
		
			
				|  |  | +    return WiFi_scanNetworks(millis()-_lastscan > cachetime,false);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +bool WiFiManager::WiFi_scanNetworks(bool force,bool async){
 | 
	
		
			
				|  |  | +    // DEBUG_WM(DEBUG_DEV,"scanNetworks async:",async == true);
 | 
	
		
			
				|  |  | +    // DEBUG_WM(DEBUG_DEV,_numNetworks,(millis()-_lastscan ));
 | 
	
		
			
				|  |  | +    // DEBUG_WM(DEBUG_DEV,"scanNetworks force:",force == true);
 | 
	
		
			
				|  |  | +    if(force || _numNetworks == 0 || (millis()-_lastscan > 60000)){
 | 
	
		
			
				|  |  | +      int8_t res;
 | 
	
		
			
				|  |  | +      _startscan = millis();
 | 
	
		
			
				|  |  | +      if(async && _asyncScan){
 | 
	
		
			
				|  |  | +        #ifdef ESP8266
 | 
	
		
			
				|  |  | +          #ifndef WM_NOASYNC // no async available < 2.4.0
 | 
	
		
			
				|  |  | +          DEBUG_WM(DEBUG_VERBOSE,F("WiFi Scan ASYNC started"));
 | 
	
		
			
				|  |  | +          using namespace std::placeholders; // for `_1`
 | 
	
		
			
				|  |  | +          WiFi.scanNetworksAsync(std::bind(&WiFiManager::WiFi_scanComplete,this,_1));
 | 
	
		
			
				|  |  | +          #else
 | 
	
		
			
				|  |  | +          res = WiFi.scanNetworks();
 | 
	
		
			
				|  |  | +          #endif
 | 
	
		
			
				|  |  | +        #else
 | 
	
		
			
				|  |  | +          DEBUG_WM(DEBUG_VERBOSE,F("WiFi Scan ASYNC started"));
 | 
	
		
			
				|  |  | +          res = WiFi.scanNetworks(true);
 | 
	
		
			
				|  |  | +        #endif
 | 
	
		
			
				|  |  | +        return false;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      else{
 | 
	
		
			
				|  |  | +        res = WiFi.scanNetworks();
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if(res == WIFI_SCAN_FAILED) DEBUG_WM(DEBUG_ERROR,"[ERROR] scan failed");
 | 
	
		
			
				|  |  | +      else if(res == WIFI_SCAN_RUNNING){
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_ERROR,"[ERROR] scan waiting");
 | 
	
		
			
				|  |  | +        while(WiFi.scanComplete() == WIFI_SCAN_RUNNING){
 | 
	
		
			
				|  |  | +          DEBUG_WM(DEBUG_ERROR,".");
 | 
	
		
			
				|  |  | +          delay(100);
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        _numNetworks = WiFi.scanComplete();
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      else if(res >=0 ) _numNetworks = res;
 | 
	
		
			
				|  |  | +      _lastscan = millis();
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_VERBOSE,F("WiFi Scan completed"), "in "+(String)(_lastscan - _startscan)+" ms");
 | 
	
		
			
				|  |  | +      return true;
 | 
	
		
			
				|  |  | +    } else DEBUG_WM(DEBUG_VERBOSE,"Scan is cached",(String)(millis()-_lastscan )+" ms ago");
 | 
	
		
			
				|  |  | +    return false;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +String WiFiManager::WiFiManager::getScanItemOut(){
 | 
	
		
			
				|  |  | +    String page;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    if(!_numNetworks) WiFi_scanNetworks(); // scan in case this gets called before any scans
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    int n = _numNetworks;
 | 
	
		
			
				|  |  | +    if (n == 0) {
 | 
	
		
			
				|  |  | +      DEBUG_WM(F("No networks found"));
 | 
	
		
			
				|  |  | +      page += FPSTR(S_nonetworks); // @token nonetworks
 | 
	
		
			
				|  |  | +    } 
 | 
	
		
			
				|  |  | +    else {
 | 
	
		
			
				|  |  | +      DEBUG_WM(n,F("networks found"));
 | 
	
		
			
				|  |  | +      //sort networks
 | 
	
		
			
				|  |  | +      int indices[n];
 | 
	
		
			
				|  |  | +      for (int i = 0; i < n; i++) {
 | 
	
		
			
				|  |  | +        indices[i] = i;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      // RSSI SORT
 | 
	
		
			
				|  |  | +      for (int i = 0; i < n; i++) {
 | 
	
		
			
				|  |  | +        for (int j = i + 1; j < n; j++) {
 | 
	
		
			
				|  |  | +          if (WiFi.RSSI(indices[j]) > WiFi.RSSI(indices[i])) {
 | 
	
		
			
				|  |  | +            std::swap(indices[i], indices[j]);
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      /* test std:sort
 | 
	
		
			
				|  |  | +        std::sort(indices, indices + n, [](const int & a, const int & b) -> bool
 | 
	
		
			
				|  |  | +        {
 | 
	
		
			
				|  |  | +        return WiFi.RSSI(a) > WiFi.RSSI(b);
 | 
	
		
			
				|  |  | +        });
 | 
	
		
			
				|  |  | +       */
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      // remove duplicates ( must be RSSI sorted )
 | 
	
		
			
				|  |  | +      if (_removeDuplicateAPs) {
 | 
	
		
			
				|  |  | +        String cssid;
 | 
	
		
			
				|  |  | +        for (int i = 0; i < n; i++) {
 | 
	
		
			
				|  |  | +          if (indices[i] == -1) continue;
 | 
	
		
			
				|  |  | +          cssid = WiFi.SSID(indices[i]);
 | 
	
		
			
				|  |  | +          for (int j = i + 1; j < n; j++) {
 | 
	
		
			
				|  |  | +            if (cssid == WiFi.SSID(indices[j])) {
 | 
	
		
			
				|  |  | +              DEBUG_WM(DEBUG_VERBOSE,F("DUP AP:"),WiFi.SSID(indices[j]));
 | 
	
		
			
				|  |  | +              indices[j] = -1; // set dup aps to index -1
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      // token precheck, to speed up replacements on large ap lists
 | 
	
		
			
				|  |  | +      String HTTP_ITEM_STR = FPSTR(HTTP_ITEM);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      // toggle icons with percentage
 | 
	
		
			
				|  |  | +      HTTP_ITEM_STR.replace("{qp}", FPSTR(HTTP_ITEM_QP));
 | 
	
		
			
				|  |  | +      HTTP_ITEM_STR.replace("{h}",_scanDispOptions ? "" : "h");
 | 
	
		
			
				|  |  | +      HTTP_ITEM_STR.replace("{qi}", FPSTR(HTTP_ITEM_QI));
 | 
	
		
			
				|  |  | +      HTTP_ITEM_STR.replace("{h}",_scanDispOptions ? "h" : "");
 | 
	
		
			
				|  |  | + 
 | 
	
		
			
				|  |  | +      // set token precheck flags
 | 
	
		
			
				|  |  | +      bool tok_r = HTTP_ITEM_STR.indexOf(FPSTR(T_r)) > 0;
 | 
	
		
			
				|  |  | +      bool tok_R = HTTP_ITEM_STR.indexOf(FPSTR(T_R)) > 0;
 | 
	
		
			
				|  |  | +      bool tok_e = HTTP_ITEM_STR.indexOf(FPSTR(T_e)) > 0;
 | 
	
		
			
				|  |  | +      bool tok_q = HTTP_ITEM_STR.indexOf(FPSTR(T_q)) > 0;
 | 
	
		
			
				|  |  | +      bool tok_i = HTTP_ITEM_STR.indexOf(FPSTR(T_i)) > 0;
 | 
	
		
			
				|  |  | +      
 | 
	
		
			
				|  |  | +      //display networks in page
 | 
	
		
			
				|  |  | +      for (int i = 0; i < n; i++) {
 | 
	
		
			
				|  |  | +        if (indices[i] == -1) continue; // skip dups
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_VERBOSE,F("AP: "),(String)WiFi.RSSI(indices[i]) + " " + (String)WiFi.SSID(indices[i]));
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        int rssiperc = getRSSIasQuality(WiFi.RSSI(indices[i]));
 | 
	
		
			
				|  |  | +        uint8_t enc_type = WiFi.encryptionType(indices[i]);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        if (_minimumQuality == -1 || _minimumQuality < rssiperc) {
 | 
	
		
			
				|  |  | +          String item = HTTP_ITEM_STR;
 | 
	
		
			
				|  |  | +          item.replace(FPSTR(T_v), htmlEntities(WiFi.SSID(indices[i]))); // ssid no encoding
 | 
	
		
			
				|  |  | +          if(tok_e) item.replace(FPSTR(T_e), encryptionTypeStr(enc_type));
 | 
	
		
			
				|  |  | +          if(tok_r) item.replace(FPSTR(T_r), (String)rssiperc); // rssi percentage 0-100
 | 
	
		
			
				|  |  | +          if(tok_R) item.replace(FPSTR(T_R), (String)WiFi.RSSI(indices[i])); // rssi db
 | 
	
		
			
				|  |  | +          if(tok_q) item.replace(FPSTR(T_q), (String)int(round(map(rssiperc,0,100,1,4)))); //quality icon 1-4
 | 
	
		
			
				|  |  | +          if(tok_i){
 | 
	
		
			
				|  |  | +            if (enc_type != WM_WIFIOPEN) {
 | 
	
		
			
				|  |  | +              item.replace(FPSTR(T_i), F("l"));
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              item.replace(FPSTR(T_i), "");
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          //DEBUG_WM(item);
 | 
	
		
			
				|  |  | +          page += item;
 | 
	
		
			
				|  |  | +          delay(0);
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          DEBUG_WM(DEBUG_VERBOSE,F("Skipping , does not meet _minimumQuality"));
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      page += FPSTR(HTTP_BR);
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    return page;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +String WiFiManager::getIpForm(String id, String title, String value){
 | 
	
		
			
				|  |  | +    String item = FPSTR(HTTP_FORM_LABEL);
 | 
	
		
			
				|  |  | +    item += FPSTR(HTTP_FORM_PARAM);
 | 
	
		
			
				|  |  | +    item.replace(FPSTR(T_i), id);
 | 
	
		
			
				|  |  | +    item.replace(FPSTR(T_n), id);
 | 
	
		
			
				|  |  | +    item.replace(FPSTR(T_p), FPSTR(T_t));
 | 
	
		
			
				|  |  | +    // item.replace(FPSTR(T_p), default);
 | 
	
		
			
				|  |  | +    item.replace(FPSTR(T_t), title);
 | 
	
		
			
				|  |  | +    item.replace(FPSTR(T_l), F("15"));
 | 
	
		
			
				|  |  | +    item.replace(FPSTR(T_v), value);
 | 
	
		
			
				|  |  | +    item.replace(FPSTR(T_c), "");
 | 
	
		
			
				|  |  | +    return item;  
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +String WiFiManager::getStaticOut(){
 | 
	
		
			
				|  |  | +  String page;
 | 
	
		
			
				|  |  | +  if ((_staShowStaticFields || _sta_static_ip) && _staShowStaticFields>=0) {
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_DEV,"_staShowStaticFields");
 | 
	
		
			
				|  |  | +    page += FPSTR(HTTP_FORM_STATIC_HEAD);
 | 
	
		
			
				|  |  | +    // @todo how can we get these accurate settings from memory , wifi_get_ip_info does not seem to reveal if struct ip_info is static or not
 | 
	
		
			
				|  |  | +    page += getIpForm(FPSTR(S_ip),FPSTR(S_staticip),(_sta_static_ip ? _sta_static_ip.toString() : "")); // @token staticip
 | 
	
		
			
				|  |  | +    // WiFi.localIP().toString();
 | 
	
		
			
				|  |  | +    page += getIpForm(FPSTR(S_gw),FPSTR(S_staticgw),(_sta_static_gw ? _sta_static_gw.toString() : "")); // @token staticgw
 | 
	
		
			
				|  |  | +    // WiFi.gatewayIP().toString();
 | 
	
		
			
				|  |  | +    page += getIpForm(FPSTR(S_sn),FPSTR(S_subnet),(_sta_static_sn ? _sta_static_sn.toString() : "")); // @token subnet
 | 
	
		
			
				|  |  | +    // WiFi.subnetMask().toString();
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if((_staShowDns || _sta_static_dns) && _staShowDns>=0){
 | 
	
		
			
				|  |  | +    page += getIpForm(FPSTR(S_dns),FPSTR(S_staticdns),(_sta_static_dns ? _sta_static_dns.toString() : "")); // @token dns
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(page!="") page += FPSTR(HTTP_BR); // @todo remove these, use css
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  return page;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +String WiFiManager::getParamOut(){
 | 
	
		
			
				|  |  | +  String page;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(_paramsCount > 0){
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    String HTTP_PARAM_temp = FPSTR(HTTP_FORM_LABEL);
 | 
	
		
			
				|  |  | +    HTTP_PARAM_temp += FPSTR(HTTP_FORM_PARAM);
 | 
	
		
			
				|  |  | +    bool tok_I = HTTP_PARAM_temp.indexOf(FPSTR(T_I)) > 0;
 | 
	
		
			
				|  |  | +    bool tok_i = HTTP_PARAM_temp.indexOf(FPSTR(T_i)) > 0;
 | 
	
		
			
				|  |  | +    bool tok_n = HTTP_PARAM_temp.indexOf(FPSTR(T_n)) > 0;
 | 
	
		
			
				|  |  | +    bool tok_p = HTTP_PARAM_temp.indexOf(FPSTR(T_p)) > 0;
 | 
	
		
			
				|  |  | +    bool tok_t = HTTP_PARAM_temp.indexOf(FPSTR(T_t)) > 0;
 | 
	
		
			
				|  |  | +    bool tok_l = HTTP_PARAM_temp.indexOf(FPSTR(T_l)) > 0;
 | 
	
		
			
				|  |  | +    bool tok_v = HTTP_PARAM_temp.indexOf(FPSTR(T_v)) > 0;
 | 
	
		
			
				|  |  | +    bool tok_c = HTTP_PARAM_temp.indexOf(FPSTR(T_c)) > 0;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    char valLength[5];
 | 
	
		
			
				|  |  | +    // add the extra parameters to the form
 | 
	
		
			
				|  |  | +    for (int i = 0; i < _paramsCount; i++) {
 | 
	
		
			
				|  |  | +      if (_params[i] == NULL || _params[i]->_length == 0) {
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_ERROR,"[ERROR] WiFiManagerParameter is out of scope");
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +     // label before or after, @todo this could be done via floats or CSS and eliminated
 | 
	
		
			
				|  |  | +     String pitem;
 | 
	
		
			
				|  |  | +      switch (_params[i]->getLabelPlacement()) {
 | 
	
		
			
				|  |  | +        case WFM_LABEL_BEFORE:
 | 
	
		
			
				|  |  | +          pitem = FPSTR(HTTP_FORM_LABEL);
 | 
	
		
			
				|  |  | +          pitem += FPSTR(HTTP_FORM_PARAM);
 | 
	
		
			
				|  |  | +          break;
 | 
	
		
			
				|  |  | +        case WFM_LABEL_AFTER:
 | 
	
		
			
				|  |  | +          pitem = FPSTR(HTTP_FORM_PARAM);
 | 
	
		
			
				|  |  | +          pitem += FPSTR(HTTP_FORM_LABEL);
 | 
	
		
			
				|  |  | +          break;
 | 
	
		
			
				|  |  | +        default:
 | 
	
		
			
				|  |  | +          // WFM_NO_LABEL
 | 
	
		
			
				|  |  | +          pitem = FPSTR(HTTP_FORM_PARAM);
 | 
	
		
			
				|  |  | +          break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      // Input templating
 | 
	
		
			
				|  |  | +      // "<br/><input id='{i}' name='{n}' maxlength='{l}' value='{v}' {c}>";
 | 
	
		
			
				|  |  | +      // if no ID use customhtml for item, else generate from param string
 | 
	
		
			
				|  |  | +      if (_params[i]->getID() != NULL) {
 | 
	
		
			
				|  |  | +        if(tok_I)pitem.replace(FPSTR(T_I), (String)FPSTR(S_parampre)+(String)i); // T_I id number
 | 
	
		
			
				|  |  | +        if(tok_i)pitem.replace(FPSTR(T_i), _params[i]->getID()); // T_i id name
 | 
	
		
			
				|  |  | +        if(tok_n)pitem.replace(FPSTR(T_n), _params[i]->getID()); // T_n id name alias
 | 
	
		
			
				|  |  | +        if(tok_p)pitem.replace(FPSTR(T_p), FPSTR(T_t)); // T_p replace legacy placeholder token
 | 
	
		
			
				|  |  | +        if(tok_t)pitem.replace(FPSTR(T_t), _params[i]->getLabel()); // T_t title/label
 | 
	
		
			
				|  |  | +        snprintf(valLength, 5, "%d", _params[i]->getValueLength());
 | 
	
		
			
				|  |  | +        if(tok_l)pitem.replace(FPSTR(T_l), valLength); // T_l value length
 | 
	
		
			
				|  |  | +        if(tok_v)pitem.replace(FPSTR(T_v), _params[i]->getValue()); // T_v value
 | 
	
		
			
				|  |  | +        if(tok_c)pitem.replace(FPSTR(T_c), _params[i]->getCustomHTML()); // T_c meant for additional attributes, not html, but can stuff
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        pitem = _params[i]->getCustomHTML();
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      page += pitem;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  return page;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +void WiFiManager::handleWiFiStatus(){
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("<- HTTP WiFi status "));
 | 
	
		
			
				|  |  | +  handleRequest();
 | 
	
		
			
				|  |  | +  String page;
 | 
	
		
			
				|  |  | +  // String page = "{\"result\":true,\"count\":1}";
 | 
	
		
			
				|  |  | +  #ifdef JSTEST
 | 
	
		
			
				|  |  | +    page = FPSTR(HTTP_JS);
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +  server->sendHeader(FPSTR(HTTP_HEAD_CL), String(page.length()));
 | 
	
		
			
				|  |  | +  server->send(200, FPSTR(HTTP_HEAD_CT), page);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/** 
 | 
	
		
			
				|  |  | + * HTTPD CALLBACK save form and redirect to WLAN config page again
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::handleWifiSave() {
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("<- HTTP WiFi save "));
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,F("Method:"),server->method() == HTTP_GET  ? (String)FPSTR(S_GET) : (String)FPSTR(S_POST));
 | 
	
		
			
				|  |  | +  handleRequest();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | + // @todo use new callback for before paramsaves
 | 
	
		
			
				|  |  | +  if ( _presavecallback != NULL) {
 | 
	
		
			
				|  |  | +    _presavecallback();
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  //SAVE/connect here
 | 
	
		
			
				|  |  | +  _ssid = server->arg(F("s")).c_str();
 | 
	
		
			
				|  |  | +  _pass = server->arg(F("p")).c_str();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(_paramsInWifi) doParamSave();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if (server->arg(FPSTR(S_ip)) != "") {
 | 
	
		
			
				|  |  | +    //_sta_static_ip.fromString(server->arg(FPSTR(S_ip));
 | 
	
		
			
				|  |  | +    String ip = server->arg(FPSTR(S_ip));
 | 
	
		
			
				|  |  | +    optionalIPFromString(&_sta_static_ip, ip.c_str());
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_DEV,F("static ip:"),ip);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (server->arg(FPSTR(S_gw)) != "") {
 | 
	
		
			
				|  |  | +    String gw = server->arg(FPSTR(S_gw));
 | 
	
		
			
				|  |  | +    optionalIPFromString(&_sta_static_gw, gw.c_str());
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_DEV,F("static gateway:"),gw);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (server->arg(FPSTR(S_sn)) != "") {
 | 
	
		
			
				|  |  | +    String sn = server->arg(FPSTR(S_sn));
 | 
	
		
			
				|  |  | +    optionalIPFromString(&_sta_static_sn, sn.c_str());
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_DEV,F("static netmask:"),sn);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (server->arg(FPSTR(S_dns)) != "") {
 | 
	
		
			
				|  |  | +    String dns = server->arg(FPSTR(S_dns));
 | 
	
		
			
				|  |  | +    optionalIPFromString(&_sta_static_dns, dns.c_str());
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_DEV,F("static DNS:"),dns);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  String page;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(_ssid == ""){
 | 
	
		
			
				|  |  | +    page = getHTTPHead(FPSTR(S_titlewifisettings)); // @token titleparamsaved
 | 
	
		
			
				|  |  | +    page += FPSTR(HTTP_PARAMSAVED);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else {
 | 
	
		
			
				|  |  | +    page = getHTTPHead(FPSTR(S_titlewifisaved)); // @token titlewifisaved
 | 
	
		
			
				|  |  | +    page += FPSTR(HTTP_SAVED);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_END);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  server->sendHeader(FPSTR(HTTP_HEAD_CL), String(page.length()));
 | 
	
		
			
				|  |  | +  server->sendHeader(FPSTR(HTTP_HEAD_CORS), FPSTR(HTTP_HEAD_CORS_ALLOW_ALL));
 | 
	
		
			
				|  |  | +  server->send(200, FPSTR(HTTP_HEAD_CT), page);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,F("Sent wifi save page"));
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  connect = true; //signal ready to connect/reset process in processConfigPortal
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +void WiFiManager::handleParamSave() {
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("<- HTTP WiFi save "));
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,F("Method:"),server->method() == HTTP_GET  ? (String)FPSTR(S_GET) : (String)FPSTR(S_POST));
 | 
	
		
			
				|  |  | +  handleRequest();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  doParamSave();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  String page = getHTTPHead(FPSTR(S_titleparamsaved)); // @token titleparamsaved
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_PARAMSAVED);
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_END);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  server->sendHeader(FPSTR(HTTP_HEAD_CL), String(page.length()));
 | 
	
		
			
				|  |  | +  server->send(200, FPSTR(HTTP_HEAD_CT), page);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,F("Sent param save page"));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +void WiFiManager::doParamSave(){
 | 
	
		
			
				|  |  | +   // @todo use new callback for before paramsaves, is this really needed?
 | 
	
		
			
				|  |  | +  if ( _presavecallback != NULL) {
 | 
	
		
			
				|  |  | +    _presavecallback();
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  //parameters
 | 
	
		
			
				|  |  | +  if(_paramsCount > 0){
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_VERBOSE,F("Parameters"));
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_VERBOSE,FPSTR(D_HR));
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    for (int i = 0; i < _paramsCount; i++) {
 | 
	
		
			
				|  |  | +      if (_params[i] == NULL || _params[i]->_length == 0) {
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_ERROR,"[ERROR] WiFiManagerParameter is out of scope");
 | 
	
		
			
				|  |  | +        break; // @todo might not be needed anymore
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      //read parameter from server
 | 
	
		
			
				|  |  | +      String name = (String)FPSTR(S_parampre)+(String)i;
 | 
	
		
			
				|  |  | +      String value;
 | 
	
		
			
				|  |  | +      if(server->hasArg(name)) {
 | 
	
		
			
				|  |  | +        value = server->arg(name);
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        value = server->arg(_params[i]->getID());
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      //store it in params array
 | 
	
		
			
				|  |  | +      value.toCharArray(_params[i]->_value, _params[i]->_length+1); // length+1 null terminated
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_VERBOSE,(String)_params[i]->getID() + ":",value);
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_VERBOSE,FPSTR(D_HR));
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +   if ( _saveparamscallback != NULL) {
 | 
	
		
			
				|  |  | +    _saveparamscallback();
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +   
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/** 
 | 
	
		
			
				|  |  | + * HTTPD CALLBACK info page
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::handleInfo() {
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("<- HTTP Info"));
 | 
	
		
			
				|  |  | +  handleRequest();
 | 
	
		
			
				|  |  | +  String page = getHTTPHead(FPSTR(S_titleinfo)); // @token titleinfo
 | 
	
		
			
				|  |  | +  reportStatus(page);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  uint16_t infos = 0;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  //@todo convert to enum or refactor to strings
 | 
	
		
			
				|  |  | +  //@todo wrap in build flag to remove all info code for memory saving
 | 
	
		
			
				|  |  | +  #ifdef ESP8266
 | 
	
		
			
				|  |  | +    infos = 27;
 | 
	
		
			
				|  |  | +    String infoids[] = {
 | 
	
		
			
				|  |  | +      F("esphead"),
 | 
	
		
			
				|  |  | +      F("uptime"),
 | 
	
		
			
				|  |  | +      F("chipid"),
 | 
	
		
			
				|  |  | +      F("fchipid"),
 | 
	
		
			
				|  |  | +      F("idesize"),
 | 
	
		
			
				|  |  | +      F("flashsize"),
 | 
	
		
			
				|  |  | +      F("sdkver"),
 | 
	
		
			
				|  |  | +      F("corever"),
 | 
	
		
			
				|  |  | +      F("bootver"),
 | 
	
		
			
				|  |  | +      F("cpufreq"),
 | 
	
		
			
				|  |  | +      F("freeheap"),
 | 
	
		
			
				|  |  | +      F("memsketch"),
 | 
	
		
			
				|  |  | +      F("memsmeter"),
 | 
	
		
			
				|  |  | +      F("lastreset"),
 | 
	
		
			
				|  |  | +      F("wifihead"),
 | 
	
		
			
				|  |  | +      F("apip"),
 | 
	
		
			
				|  |  | +      F("apmac"),
 | 
	
		
			
				|  |  | +      F("apssid"),
 | 
	
		
			
				|  |  | +      F("apbssid"),
 | 
	
		
			
				|  |  | +      F("staip"),
 | 
	
		
			
				|  |  | +      F("stagw"),
 | 
	
		
			
				|  |  | +      F("stasub"),
 | 
	
		
			
				|  |  | +      F("dnss"),
 | 
	
		
			
				|  |  | +      F("host"),
 | 
	
		
			
				|  |  | +      F("stamac"),
 | 
	
		
			
				|  |  | +      F("conx"),
 | 
	
		
			
				|  |  | +      F("autoconx")
 | 
	
		
			
				|  |  | +    };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  #elif defined(ESP32)
 | 
	
		
			
				|  |  | +    infos = 22;
 | 
	
		
			
				|  |  | +    String infoids[] = {
 | 
	
		
			
				|  |  | +      F("esphead"),
 | 
	
		
			
				|  |  | +      F("uptime"),
 | 
	
		
			
				|  |  | +      F("chipid"),
 | 
	
		
			
				|  |  | +      F("chiprev"),
 | 
	
		
			
				|  |  | +      F("idesize"),
 | 
	
		
			
				|  |  | +      F("sdkver"),
 | 
	
		
			
				|  |  | +      F("cpufreq"),
 | 
	
		
			
				|  |  | +      F("freeheap"),
 | 
	
		
			
				|  |  | +      F("lastreset"),
 | 
	
		
			
				|  |  | +      // F("temp"),
 | 
	
		
			
				|  |  | +      F("wifihead"),
 | 
	
		
			
				|  |  | +      F("apip"),
 | 
	
		
			
				|  |  | +      F("apmac"),
 | 
	
		
			
				|  |  | +      F("aphost"),
 | 
	
		
			
				|  |  | +      F("apssid"),
 | 
	
		
			
				|  |  | +      F("apbssid"),
 | 
	
		
			
				|  |  | +      F("staip"),
 | 
	
		
			
				|  |  | +      F("stagw"),
 | 
	
		
			
				|  |  | +      F("stasub"),
 | 
	
		
			
				|  |  | +      F("dnss"),
 | 
	
		
			
				|  |  | +      F("host"),
 | 
	
		
			
				|  |  | +      F("stamac"),
 | 
	
		
			
				|  |  | +      F("conx")
 | 
	
		
			
				|  |  | +    };
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  for(size_t i=0; i<infos;i++){
 | 
	
		
			
				|  |  | +    if(infoids[i] != NULL) page += getInfoData(infoids[i]);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  page += F("</dl>");
 | 
	
		
			
				|  |  | +  if(_showInfoErase) page += FPSTR(HTTP_ERASEBTN);
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_HELP);
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_END);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  server->sendHeader(FPSTR(HTTP_HEAD_CL), String(page.length()));
 | 
	
		
			
				|  |  | +  server->send(200, FPSTR(HTTP_HEAD_CT), page);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,F("Sent info page"));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +String WiFiManager::getInfoData(String id){
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  String p;
 | 
	
		
			
				|  |  | +  // @todo add WM versioning
 | 
	
		
			
				|  |  | +  if(id==F("esphead"))p = FPSTR(HTTP_INFO_esphead);
 | 
	
		
			
				|  |  | +  else if(id==F("wifihead"))p = FPSTR(HTTP_INFO_wifihead);
 | 
	
		
			
				|  |  | +  else if(id==F("uptime")){
 | 
	
		
			
				|  |  | +    // subject to rollover!
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_uptime);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),(String)(millis() / 1000 / 60));
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_2),(String)((millis() / 1000) % 60));
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("chipid")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_chipid);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),String(WIFI_getChipId(),HEX));
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  #ifdef ESP32
 | 
	
		
			
				|  |  | +  else if(id==F("chiprev")){
 | 
	
		
			
				|  |  | +      p = FPSTR(HTTP_INFO_chiprev);
 | 
	
		
			
				|  |  | +      String rev = (String)ESP.getChipRevision();
 | 
	
		
			
				|  |  | +      #ifdef _SOC_EFUSE_REG_H_
 | 
	
		
			
				|  |  | +        String revb = (String)(REG_READ(EFUSE_BLK0_RDATA3_REG) >> (EFUSE_RD_CHIP_VER_RESERVE_S)&&EFUSE_RD_CHIP_VER_RESERVE_V);
 | 
	
		
			
				|  |  | +        p.replace(FPSTR(T_1),rev+"<br/>"+revb);
 | 
	
		
			
				|  |  | +      #else
 | 
	
		
			
				|  |  | +        p.replace(FPSTR(T_1),rev);
 | 
	
		
			
				|  |  | +      #endif
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +  #ifdef ESP8266
 | 
	
		
			
				|  |  | +  else if(id==F("fchipid")){
 | 
	
		
			
				|  |  | +      p = FPSTR(HTTP_INFO_fchipid);
 | 
	
		
			
				|  |  | +      p.replace(FPSTR(T_1),(String)ESP.getFlashChipId());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +  else if(id==F("idesize")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_idesize);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),(String)ESP.getFlashChipSize());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("flashsize")){
 | 
	
		
			
				|  |  | +    #ifdef ESP8266
 | 
	
		
			
				|  |  | +      p = FPSTR(HTTP_INFO_flashsize);
 | 
	
		
			
				|  |  | +      p.replace(FPSTR(T_1),(String)ESP.getFlashChipRealSize());
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("sdkver")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_sdkver);
 | 
	
		
			
				|  |  | +    #ifdef ESP32
 | 
	
		
			
				|  |  | +      p.replace(FPSTR(T_1),(String)esp_get_idf_version());
 | 
	
		
			
				|  |  | +    #else
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),(String)system_get_sdk_version());
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("corever")){
 | 
	
		
			
				|  |  | +    #ifdef ESP8266
 | 
	
		
			
				|  |  | +      p = FPSTR(HTTP_INFO_corever);
 | 
	
		
			
				|  |  | +      p.replace(FPSTR(T_1),(String)ESP.getCoreVersion());
 | 
	
		
			
				|  |  | +    #endif      
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  #ifdef ESP8266
 | 
	
		
			
				|  |  | +  else if(id==F("bootver")){
 | 
	
		
			
				|  |  | +      p = FPSTR(HTTP_INFO_bootver);
 | 
	
		
			
				|  |  | +      p.replace(FPSTR(T_1),(String)system_get_boot_version());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  #endif  
 | 
	
		
			
				|  |  | +  else if(id==F("cpufreq")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_cpufreq);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),(String)ESP.getCpuFreqMHz());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("freeheap")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_freeheap);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),(String)ESP.getFreeHeap());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  #ifdef ESP8266
 | 
	
		
			
				|  |  | +  else if(id==F("memsketch")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_memsketch);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),(String)(ESP.getSketchSize()));
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_2),(String)(ESP.getSketchSize()+ESP.getFreeSketchSpace()));
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  #endif  
 | 
	
		
			
				|  |  | +  #ifdef ESP8266
 | 
	
		
			
				|  |  | +  else if(id==F("memsmeter")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_memsmeter);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),(String)(ESP.getSketchSize()));
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_2),(String)(ESP.getSketchSize()+ESP.getFreeSketchSpace()));
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  #endif 
 | 
	
		
			
				|  |  | +  else if(id==F("lastreset")){
 | 
	
		
			
				|  |  | +    #ifdef ESP8266
 | 
	
		
			
				|  |  | +      p = FPSTR(HTTP_INFO_lastreset);
 | 
	
		
			
				|  |  | +      p.replace(FPSTR(T_1),(String)ESP.getResetReason());
 | 
	
		
			
				|  |  | +    #elif defined(ESP32) && defined(_ROM_RTC_H_)
 | 
	
		
			
				|  |  | +      // requires #include <rom/rtc.h>
 | 
	
		
			
				|  |  | +      p = FPSTR(HTTP_INFO_lastreset);
 | 
	
		
			
				|  |  | +      for(int i=0;i<2;i++){
 | 
	
		
			
				|  |  | +        int reason = rtc_get_reset_reason(i);
 | 
	
		
			
				|  |  | +        String tok = (String)T_ss+(String)(i+1)+(String)T_es;
 | 
	
		
			
				|  |  | +        switch (reason)
 | 
	
		
			
				|  |  | +        {
 | 
	
		
			
				|  |  | +          //@todo move to array
 | 
	
		
			
				|  |  | +          case 1  : p.replace(tok,F("Vbat power on reset"));break;
 | 
	
		
			
				|  |  | +          case 3  : p.replace(tok,F("Software reset digital core"));break;
 | 
	
		
			
				|  |  | +          case 4  : p.replace(tok,F("Legacy watch dog reset digital core"));break;
 | 
	
		
			
				|  |  | +          case 5  : p.replace(tok,F("Deep Sleep reset digital core"));break;
 | 
	
		
			
				|  |  | +          case 6  : p.replace(tok,F("Reset by SLC module, reset digital core"));break;
 | 
	
		
			
				|  |  | +          case 7  : p.replace(tok,F("Timer Group0 Watch dog reset digital core"));break;
 | 
	
		
			
				|  |  | +          case 8  : p.replace(tok,F("Timer Group1 Watch dog reset digital core"));break;
 | 
	
		
			
				|  |  | +          case 9  : p.replace(tok,F("RTC Watch dog Reset digital core"));break;
 | 
	
		
			
				|  |  | +          case 10 : p.replace(tok,F("Instrusion tested to reset CPU"));break;
 | 
	
		
			
				|  |  | +          case 11 : p.replace(tok,F("Time Group reset CPU"));break;
 | 
	
		
			
				|  |  | +          case 12 : p.replace(tok,F("Software reset CPU"));break;
 | 
	
		
			
				|  |  | +          case 13 : p.replace(tok,F("RTC Watch dog Reset CPU"));break;
 | 
	
		
			
				|  |  | +          case 14 : p.replace(tok,F("for APP CPU, reseted by PRO CPU"));break;
 | 
	
		
			
				|  |  | +          case 15 : p.replace(tok,F("Reset when the vdd voltage is not stable"));break;
 | 
	
		
			
				|  |  | +          case 16 : p.replace(tok,F("RTC Watch dog reset digital core and rtc module"));break;
 | 
	
		
			
				|  |  | +          default : p.replace(tok,F("NO_MEAN"));
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("apip")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_apip);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),WiFi.softAPIP().toString());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("apmac")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_apmac);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),(String)WiFi.softAPmacAddress());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  #ifdef ESP32
 | 
	
		
			
				|  |  | +  else if(id==F("aphost")){
 | 
	
		
			
				|  |  | +      p = FPSTR(HTTP_INFO_aphost);
 | 
	
		
			
				|  |  | +      p.replace(FPSTR(T_1),WiFi.softAPgetHostname());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +  else if(id==F("apssid")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_apssid);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),htmlEntities((String)WiFi_SSID()));
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("apbssid")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_apbssid);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),(String)WiFi.BSSIDstr());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("staip")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_staip);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),WiFi.localIP().toString());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("stagw")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_stagw);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),WiFi.gatewayIP().toString());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("stasub")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_stasub);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),WiFi.subnetMask().toString());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("dnss")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_dnss);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),WiFi.dnsIP().toString());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("host")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_host);
 | 
	
		
			
				|  |  | +    #ifdef ESP32
 | 
	
		
			
				|  |  | +      p.replace(FPSTR(T_1),WiFi.getHostname());
 | 
	
		
			
				|  |  | +    #else
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),WiFi.hostname());
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("stamac")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_stamac);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),WiFi.macAddress());
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(id==F("conx")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_conx);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),WiFi.isConnected() ? FPSTR(S_y) : FPSTR(S_n));
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  #ifdef ESP8266
 | 
	
		
			
				|  |  | +  else if(id==F("autoconx")){
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_autoconx);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),WiFi.getAutoConnect() ? FPSTR(S_enable) : FPSTR(S_disable));
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +  #ifdef ESP32
 | 
	
		
			
				|  |  | +  else if(id==F("temp")){
 | 
	
		
			
				|  |  | +    // temperature is not calibrated, varying large offsets are present, use for relative temp changes only
 | 
	
		
			
				|  |  | +    p = FPSTR(HTTP_INFO_temp);
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_1),(String)temperatureRead());
 | 
	
		
			
				|  |  | +    p.replace(FPSTR(T_2),(String)((temperatureRead()+32)*1.8));
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +  return p;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/** 
 | 
	
		
			
				|  |  | + * HTTPD CALLBACK root or redirect to captive portal
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::handleExit() {
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("<- HTTP Exit"));
 | 
	
		
			
				|  |  | +  handleRequest();
 | 
	
		
			
				|  |  | +  String page = getHTTPHead(FPSTR(S_titleexit)); // @token titleexit
 | 
	
		
			
				|  |  | +  page += FPSTR(S_exiting); // @token exiting
 | 
	
		
			
				|  |  | +  server->sendHeader(FPSTR(HTTP_HEAD_CL), String(page.length()));
 | 
	
		
			
				|  |  | +  server->send(200, FPSTR(HTTP_HEAD_CT), page);
 | 
	
		
			
				|  |  | +  abort = true;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/** 
 | 
	
		
			
				|  |  | + * HTTPD CALLBACK reset page
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::handleReset() {
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("<- HTTP Reset"));
 | 
	
		
			
				|  |  | +  handleRequest();
 | 
	
		
			
				|  |  | +  String page = getHTTPHead(FPSTR(S_titlereset)); //@token titlereset
 | 
	
		
			
				|  |  | +  page += FPSTR(S_resetting); //@token resetting
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_END);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  server->sendHeader(FPSTR(HTTP_HEAD_CL), String(page.length()));
 | 
	
		
			
				|  |  | +  server->send(200, FPSTR(HTTP_HEAD_CT), page);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM(F("RESETTING ESP"));
 | 
	
		
			
				|  |  | +  delay(1000);
 | 
	
		
			
				|  |  | +  reboot();
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/** 
 | 
	
		
			
				|  |  | + * HTTPD CALLBACK erase page
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// void WiFiManager::handleErase() {
 | 
	
		
			
				|  |  | +//   handleErase(false);
 | 
	
		
			
				|  |  | +// }
 | 
	
		
			
				|  |  | +void WiFiManager::handleErase(boolean opt) {
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("<- HTTP Erase"));
 | 
	
		
			
				|  |  | +  handleRequest();
 | 
	
		
			
				|  |  | +  String page = getHTTPHead(FPSTR(S_titleerase)); // @token titleerase
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  bool ret = erase(opt);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(ret) page += FPSTR(S_resetting); // @token resetting
 | 
	
		
			
				|  |  | +  else {
 | 
	
		
			
				|  |  | +    page += FPSTR(S_error); // @token erroroccur
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_ERROR,F("[ERROR] WiFi EraseConfig failed"));
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  page += FPSTR(HTTP_END);
 | 
	
		
			
				|  |  | +  server->sendHeader(FPSTR(HTTP_HEAD_CL), String(page.length()));
 | 
	
		
			
				|  |  | +  server->send(200, FPSTR(HTTP_HEAD_CT), page);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(ret){
 | 
	
		
			
				|  |  | +    delay(2000);
 | 
	
		
			
				|  |  | +  	DEBUG_WM(F("RESETTING ESP"));
 | 
	
		
			
				|  |  | +  	reboot();
 | 
	
		
			
				|  |  | +  }	
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/** 
 | 
	
		
			
				|  |  | + * HTTPD CALLBACK 404
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::handleNotFound() {
 | 
	
		
			
				|  |  | +  if (captivePortal()) return; // If captive portal redirect instead of displaying the page
 | 
	
		
			
				|  |  | +  handleRequest();
 | 
	
		
			
				|  |  | +  String message = FPSTR(S_notfound); // @token notfound
 | 
	
		
			
				|  |  | +  message += FPSTR(S_uri); // @token uri
 | 
	
		
			
				|  |  | +  message += server->uri();
 | 
	
		
			
				|  |  | +  message += FPSTR(S_method); // @token method
 | 
	
		
			
				|  |  | +  message += ( server->method() == HTTP_GET ) ? FPSTR(S_GET) : FPSTR(S_POST);
 | 
	
		
			
				|  |  | +  message += FPSTR(S_args); // @token args
 | 
	
		
			
				|  |  | +  message += server->args();
 | 
	
		
			
				|  |  | +  message += F("\n");
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  for ( uint8_t i = 0; i < server->args(); i++ ) {
 | 
	
		
			
				|  |  | +    message += " " + server->argName ( i ) + ": " + server->arg ( i ) + "\n";
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  server->sendHeader(F("Cache-Control"), F("no-cache, no-store, must-revalidate"));
 | 
	
		
			
				|  |  | +  server->sendHeader(F("Pragma"), F("no-cache"));
 | 
	
		
			
				|  |  | +  server->sendHeader(F("Expires"), F("-1"));
 | 
	
		
			
				|  |  | +  server->sendHeader(FPSTR(HTTP_HEAD_CL), String(message.length()));
 | 
	
		
			
				|  |  | +  server->send ( 404, FPSTR(HTTP_HEAD_CT2), message );
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * HTTPD redirector
 | 
	
		
			
				|  |  | + * Redirect to captive portal if we got a request for another domain. 
 | 
	
		
			
				|  |  | + * Return true in that case so the page handler do not try to handle the request again. 
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +boolean WiFiManager::captivePortal() {
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_DEV,"-> " + server->hostHeader());
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  if(!_enableCaptivePortal) return false; // skip redirections
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if (!isIp(server->hostHeader())) {
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_VERBOSE,F("<- Request redirected to captive portal"));
 | 
	
		
			
				|  |  | +    server->sendHeader(F("Location"), (String)F("http://") + toStringIp(server->client().localIP()), true);
 | 
	
		
			
				|  |  | +    server->send ( 302, FPSTR(HTTP_HEAD_CT2), ""); // Empty content inhibits Content-length header so we have to close the socket ourselves.
 | 
	
		
			
				|  |  | +    server->client().stop(); // Stop is needed because we sent no content length
 | 
	
		
			
				|  |  | +    return true;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return false;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +void WiFiManager::stopCaptivePortal(){
 | 
	
		
			
				|  |  | +  _enableCaptivePortal= false;
 | 
	
		
			
				|  |  | +  // @todo maybe disable configportaltimeout(optional), or just provide callback for user
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +void WiFiManager::handleClose(){
 | 
	
		
			
				|  |  | +  stopCaptivePortal();
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_VERBOSE,F("<- HTTP close"));
 | 
	
		
			
				|  |  | +  handleRequest();
 | 
	
		
			
				|  |  | +  String page = getHTTPHead(FPSTR(S_titleclose)); // @token titleclose
 | 
	
		
			
				|  |  | +  page += FPSTR(S_closing); // @token closing
 | 
	
		
			
				|  |  | +  server->sendHeader(FPSTR(HTTP_HEAD_CL), String(page.length()));
 | 
	
		
			
				|  |  | +  server->send(200, FPSTR(HTTP_HEAD_CT), page);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +void WiFiManager::reportStatus(String &page){
 | 
	
		
			
				|  |  | +  updateConxResult(WiFi.status());
 | 
	
		
			
				|  |  | +  String str;
 | 
	
		
			
				|  |  | +  if (WiFi_SSID() != ""){
 | 
	
		
			
				|  |  | +    if (WiFi.status()==WL_CONNECTED){
 | 
	
		
			
				|  |  | +      str = FPSTR(HTTP_STATUS_ON);
 | 
	
		
			
				|  |  | +      str.replace(FPSTR(T_i),WiFi.localIP().toString());
 | 
	
		
			
				|  |  | +      str.replace(FPSTR(T_v),htmlEntities(WiFi_SSID()));
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    else {
 | 
	
		
			
				|  |  | +      str = FPSTR(HTTP_STATUS_OFF);
 | 
	
		
			
				|  |  | +      str.replace(FPSTR(T_v),htmlEntities(WiFi_SSID()));
 | 
	
		
			
				|  |  | +      if(_lastconxresult == WL_STATION_WRONG_PASSWORD){
 | 
	
		
			
				|  |  | +        // wrong password
 | 
	
		
			
				|  |  | +        str.replace(FPSTR(T_c),"D"); // class
 | 
	
		
			
				|  |  | +        str.replace(FPSTR(T_r),FPSTR(HTTP_STATUS_OFFPW));
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      else if(_lastconxresult == WL_NO_SSID_AVAIL){
 | 
	
		
			
				|  |  | +        // connect failed, or ap not found
 | 
	
		
			
				|  |  | +        str.replace(FPSTR(T_c),"D");
 | 
	
		
			
				|  |  | +        str.replace(FPSTR(T_r),FPSTR(HTTP_STATUS_OFFNOAP));
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      else if(_lastconxresult == WL_CONNECT_FAILED){
 | 
	
		
			
				|  |  | +        // connect failed
 | 
	
		
			
				|  |  | +        str.replace(FPSTR(T_c),"D");
 | 
	
		
			
				|  |  | +        str.replace(FPSTR(T_r),FPSTR(HTTP_STATUS_OFFFAIL));
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      else{
 | 
	
		
			
				|  |  | +        str.replace(FPSTR(T_c),"");
 | 
	
		
			
				|  |  | +        str.replace(FPSTR(T_r),"");
 | 
	
		
			
				|  |  | +      } 
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else {
 | 
	
		
			
				|  |  | +    str = FPSTR(HTTP_STATUS_NONE);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  page += str;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// PUBLIC
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// METHODS
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * reset wifi settings, clean stored ap password
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [stopConfigPortal description]
 | 
	
		
			
				|  |  | + * @return {[type]} [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +bool WiFiManager::stopConfigPortal(){
 | 
	
		
			
				|  |  | +  if(_configPortalIsBlocking){
 | 
	
		
			
				|  |  | +    abort = true;
 | 
	
		
			
				|  |  | +    return true;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return shutdownConfigPortal();  
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * disconnect
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @return bool success
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +bool WiFiManager::disconnect(){
 | 
	
		
			
				|  |  | +  if(WiFi.status() != WL_CONNECTED){
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_VERBOSE,"Disconnecting: Not connected");
 | 
	
		
			
				|  |  | +    return false;
 | 
	
		
			
				|  |  | +  }  
 | 
	
		
			
				|  |  | +  DEBUG_WM("Disconnecting");
 | 
	
		
			
				|  |  | +  return WiFi_Disconnect();
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * reboot the device
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::reboot(){
 | 
	
		
			
				|  |  | +  DEBUG_WM("Restarting");
 | 
	
		
			
				|  |  | +  ESP.restart();
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * reboot the device
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +bool WiFiManager::erase(){
 | 
	
		
			
				|  |  | +  return erase(false);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +bool WiFiManager::erase(bool opt){
 | 
	
		
			
				|  |  | +  DEBUG_WM("Erasing");
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  #if defined(ESP32) && ((defined(WM_ERASE_NVS) || defined(nvs_flash_h)))
 | 
	
		
			
				|  |  | +    // if opt true, do nvs erase
 | 
	
		
			
				|  |  | +    if(opt){
 | 
	
		
			
				|  |  | +      DEBUG_WM("Erasing NVS");
 | 
	
		
			
				|  |  | +      int err;
 | 
	
		
			
				|  |  | +      esp_err_t err;
 | 
	
		
			
				|  |  | +      err = nvs_flash_init();
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_VERBOSE,"nvs_flash_init: ",err!=ESP_OK ? (String)err : "Success");
 | 
	
		
			
				|  |  | +      err = nvs_flash_erase();
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_VERBOSE,"nvs_flash_erase: ", err!=ESP_OK ? (String)err : "Success");
 | 
	
		
			
				|  |  | +      return err == ESP_OK;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  #elif defined(ESP8266) && defined(spiffs_api_h)
 | 
	
		
			
				|  |  | +    if(opt){
 | 
	
		
			
				|  |  | +      bool ret = false;
 | 
	
		
			
				|  |  | +      if(SPIFFS.begin()){
 | 
	
		
			
				|  |  | +        DEBUG_WM("Erasing SPIFFS");
 | 
	
		
			
				|  |  | +        bool ret = SPIFFS.format();
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_VERBOSE,"spiffs erase: ",ret ? "Success" : "ERROR");
 | 
	
		
			
				|  |  | +      } else DEBUG_WM("[ERROR] Could not start SPIFFS");
 | 
	
		
			
				|  |  | +      return ret;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  #else
 | 
	
		
			
				|  |  | +    (void)opt;
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  DEBUG_WM("Erasing WiFi Config");
 | 
	
		
			
				|  |  | +  return WiFi_eraseConfig();
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [resetSettings description]
 | 
	
		
			
				|  |  | + * ERASES STA CREDENTIALS
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::resetSettings() {
 | 
	
		
			
				|  |  | +  DEBUG_WM(F("SETTINGS ERASED"));
 | 
	
		
			
				|  |  | +  WiFi_enableSTA(true,true); // must be sta to disconnect erase
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  if (_resetcallback != NULL)
 | 
	
		
			
				|  |  | +      _resetcallback();
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  #ifdef ESP32
 | 
	
		
			
				|  |  | +    WiFi.disconnect(true,true);
 | 
	
		
			
				|  |  | +  #else
 | 
	
		
			
				|  |  | +    WiFi.persistent(true);
 | 
	
		
			
				|  |  | +    WiFi.disconnect(true);
 | 
	
		
			
				|  |  | +    WiFi.persistent(false);
 | 
	
		
			
				|  |  | +  #endif  
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// SETTERS
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [setTimeout description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} unsigned long seconds [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setTimeout(unsigned long seconds) {
 | 
	
		
			
				|  |  | +  setConfigPortalTimeout(seconds);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [setConfigPortalTimeout description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} unsigned long seconds [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setConfigPortalTimeout(unsigned long seconds) {
 | 
	
		
			
				|  |  | +  _configPortalTimeout = seconds * 1000;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [setConnectTimeout description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} unsigned long seconds [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setConnectTimeout(unsigned long seconds) {
 | 
	
		
			
				|  |  | +  _connectTimeout = seconds * 1000;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle _cleanconnect, always disconnect before connecting
 | 
	
		
			
				|  |  | + * @param {[type]} bool enable [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setCleanConnect(bool enable){
 | 
	
		
			
				|  |  | +  _cleanConnect = enable;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [setConnectTimeout description
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} unsigned long seconds [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setSaveConnectTimeout(unsigned long seconds) {
 | 
	
		
			
				|  |  | +  _saveTimeout = seconds * 1000;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [setDebugOutput description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} boolean debug [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setDebugOutput(boolean debug) {
 | 
	
		
			
				|  |  | +  _debug = debug;
 | 
	
		
			
				|  |  | +  if(_debug && _debugLevel == DEBUG_DEV) debugPlatformInfo();
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [setAPStaticIPConfig description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} IPAddress ip [description]
 | 
	
		
			
				|  |  | + * @param {[type]} IPAddress gw [description]
 | 
	
		
			
				|  |  | + * @param {[type]} IPAddress sn [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setAPStaticIPConfig(IPAddress ip, IPAddress gw, IPAddress sn) {
 | 
	
		
			
				|  |  | +  _ap_static_ip = ip;
 | 
	
		
			
				|  |  | +  _ap_static_gw = gw;
 | 
	
		
			
				|  |  | +  _ap_static_sn = sn;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [setSTAStaticIPConfig description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} IPAddress ip [description]
 | 
	
		
			
				|  |  | + * @param {[type]} IPAddress gw [description]
 | 
	
		
			
				|  |  | + * @param {[type]} IPAddress sn [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setSTAStaticIPConfig(IPAddress ip, IPAddress gw, IPAddress sn) {
 | 
	
		
			
				|  |  | +  _sta_static_ip = ip;
 | 
	
		
			
				|  |  | +  _sta_static_gw = gw;
 | 
	
		
			
				|  |  | +  _sta_static_sn = sn;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [setSTAStaticIPConfig description]
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} IPAddress ip [description]
 | 
	
		
			
				|  |  | + * @param {[type]} IPAddress gw [description]
 | 
	
		
			
				|  |  | + * @param {[type]} IPAddress sn [description]
 | 
	
		
			
				|  |  | + * @param {[type]} IPAddress dns [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setSTAStaticIPConfig(IPAddress ip, IPAddress gw, IPAddress sn, IPAddress dns) {
 | 
	
		
			
				|  |  | +  setSTAStaticIPConfig(ip,gw,sn);
 | 
	
		
			
				|  |  | +  _sta_static_dns = dns;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [setMinimumSignalQuality description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} int quality [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setMinimumSignalQuality(int quality) {
 | 
	
		
			
				|  |  | +  _minimumQuality = quality;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [setBreakAfterConfig description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} boolean shouldBreak [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setBreakAfterConfig(boolean shouldBreak) {
 | 
	
		
			
				|  |  | +  _shouldBreakAfterConfig = shouldBreak;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * setAPCallback, set a callback when softap is started
 | 
	
		
			
				|  |  | + * @access public 
 | 
	
		
			
				|  |  | + * @param {[type]} void (*func)(WiFiManager* wminstance)
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setAPCallback( std::function<void(WiFiManager*)> func ) {
 | 
	
		
			
				|  |  | +  _apcallback = func;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * setWebServerCallback, set a callback after webserver is reset, and before routes are setup
 | 
	
		
			
				|  |  | + * if we set webserver handlers before wm, they are used and wm is not by esp webserver
 | 
	
		
			
				|  |  | + * on events cannot be overrided once set, and are not mutiples
 | 
	
		
			
				|  |  | + * @access public 
 | 
	
		
			
				|  |  | + * @param {[type]} void (*func)(void)
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setWebServerCallback( std::function<void()> func ) {
 | 
	
		
			
				|  |  | +  _webservercallback = func;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * setSaveConfigCallback, set a save config callback after closing configportal
 | 
	
		
			
				|  |  | + * @note calls only if wifi is saved or changed, or setBreakAfterConfig(true)
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} void (*func)(void)
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setSaveConfigCallback( std::function<void()> func ) {
 | 
	
		
			
				|  |  | +  _savewificallback = func;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * setConfigResetCallback, set a callback to occur when a resetSettings() occurs
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} void(*func)(void)
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setConfigResetCallback( std::function<void()> func ) {
 | 
	
		
			
				|  |  | +    _resetcallback = func;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * setSaveParamsCallback, set a save params callback on params save in wifi or params pages
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} void (*func)(void)
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setSaveParamsCallback( std::function<void()> func ) {
 | 
	
		
			
				|  |  | +  _saveparamscallback = func;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * setPreSaveConfigCallback, set a callback to fire before saving wifi or params
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param {[type]} void (*func)(void)
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setPreSaveConfigCallback( std::function<void()> func ) {
 | 
	
		
			
				|  |  | +  _presavecallback = func;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * set custom head html
 | 
	
		
			
				|  |  | + * custom element will be added to head, eg. new style tag etc.
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param char element
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setCustomHeadElement(const char* element) {
 | 
	
		
			
				|  |  | +  _customHeadElement = element;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle wifiscan hiding of duplicate ssid names
 | 
	
		
			
				|  |  | + * if this is false, wifiscan will remove duplicat Access Points - defaut true
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param boolean removeDuplicates [true]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setRemoveDuplicateAPs(boolean removeDuplicates) {
 | 
	
		
			
				|  |  | +  _removeDuplicateAPs = removeDuplicates;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle configportal blocking loop
 | 
	
		
			
				|  |  | + * if enabled, then the configportal will enter a blocking loop and wait for configuration
 | 
	
		
			
				|  |  | + * if disabled use with process() to manually process webserver
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param boolean shoudlBlock [false]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setConfigPortalBlocking(boolean shoudlBlock) {
 | 
	
		
			
				|  |  | +  _configPortalIsBlocking = shoudlBlock;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle restore persistent, track internally
 | 
	
		
			
				|  |  | + * sets ESP wifi.persistent so we can remember it and restore user preference on destruct
 | 
	
		
			
				|  |  | + * there is no getter in esp8266 platform prior to https://github.com/esp8266/Arduino/pull/3857
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param boolean persistent [true]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setRestorePersistent(boolean persistent) {
 | 
	
		
			
				|  |  | +  _userpersistent = persistent;
 | 
	
		
			
				|  |  | +  if(!persistent) DEBUG_WM(F("persistent is off"));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle showing static ip form fields
 | 
	
		
			
				|  |  | + * if enabled, then the static ip, gateway, subnet fields will be visible, even if not set in code
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param boolean alwaysShow [false]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setShowStaticFields(boolean alwaysShow){
 | 
	
		
			
				|  |  | +  if(_disableIpFields) _staShowStaticFields = alwaysShow ? 1 : -1;
 | 
	
		
			
				|  |  | +  else _staShowStaticFields = alwaysShow ? 1 : 0;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle showing dns fields
 | 
	
		
			
				|  |  | + * if enabled, then the dns1 field will be visible, even if not set in code
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param boolean alwaysShow [false]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setShowDnsFields(boolean alwaysShow){
 | 
	
		
			
				|  |  | +  if(_disableIpFields) _staShowDns = alwaysShow ? 1 : -1;
 | 
	
		
			
				|  |  | +  _staShowDns = alwaysShow ? 1 : 0;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle showing password in wifi password field
 | 
	
		
			
				|  |  | + * if not enabled, placeholder will be S_passph
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param boolean alwaysShow [false]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setShowPassword(boolean show){
 | 
	
		
			
				|  |  | +  _showPassword = show;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle captive portal
 | 
	
		
			
				|  |  | + * if enabled, then devices that use captive portal checks will be redirected to root
 | 
	
		
			
				|  |  | + * if not you will automatically have to navigate to ip [192.168.4.1]
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param boolean enabled [true]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setCaptivePortalEnable(boolean enabled){
 | 
	
		
			
				|  |  | +  _enableCaptivePortal = enabled;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle wifi autoreconnect policy
 | 
	
		
			
				|  |  | + * if enabled, then wifi will autoreconnect automatically always
 | 
	
		
			
				|  |  | + * On esp8266 we force this on when autoconnect is called, see notes
 | 
	
		
			
				|  |  | + * On esp32 this is handled on SYSTEM_EVENT_STA_DISCONNECTED since it does not exist in core yet
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param boolean enabled [true]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setWiFiAutoReconnect(boolean enabled){
 | 
	
		
			
				|  |  | +  _wifiAutoReconnect = enabled;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle configportal timeout wait for station client
 | 
	
		
			
				|  |  | + * if enabled, then the configportal will start timeout when no stations are connected to softAP
 | 
	
		
			
				|  |  | + * disabled by default as rogue stations can keep it open if there is no auth
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param boolean enabled [false]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setAPClientCheck(boolean enabled){
 | 
	
		
			
				|  |  | +  _apClientCheck = enabled;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle configportal timeout wait for web client
 | 
	
		
			
				|  |  | + * if enabled, then the configportal will restart timeout when client requests come in
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param boolean enabled [true]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setWebPortalClientCheck(boolean enabled){
 | 
	
		
			
				|  |  | +  _webClientCheck = enabled;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle wifiscan percentages or quality icons
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param boolean enabled [false]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setScanDispPerc(boolean enabled){
 | 
	
		
			
				|  |  | +  _scanDispOptions = enabled;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle configportal if autoconnect failed
 | 
	
		
			
				|  |  | + * if enabled, then the configportal will be activated on autoconnect failure
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param boolean enabled [true]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setEnableConfigPortal(boolean enable)
 | 
	
		
			
				|  |  | +{
 | 
	
		
			
				|  |  | +    _enableConfigPortal = enable;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * set the hostname (dhcp client id)
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param  char* hostname 32 character hostname to use for sta+ap in esp32, sta in esp8266
 | 
	
		
			
				|  |  | + * @return bool false if hostname is not valid
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +bool  WiFiManager::setHostname(const char * hostname){
 | 
	
		
			
				|  |  | +  //@todo max length 32
 | 
	
		
			
				|  |  | +  _hostname = hostname;
 | 
	
		
			
				|  |  | +  return true;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * set the soft ao channel, ignored if channelsync is true and connected
 | 
	
		
			
				|  |  | + * @param int32_t   wifi channel, 0 to disable
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setWiFiAPChannel(int32_t channel){
 | 
	
		
			
				|  |  | +  _apChannel = channel;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * set the soft ap hidden
 | 
	
		
			
				|  |  | + * @param bool   wifi ap hidden, default is false
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setWiFiAPHidden(bool hidden){
 | 
	
		
			
				|  |  | +  _apHidden = hidden;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * toggle showing erase wifi config button on info page
 | 
	
		
			
				|  |  | + * @param boolean enabled
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setShowInfoErase(boolean enabled){
 | 
	
		
			
				|  |  | +  _showInfoErase = enabled;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * set menu items and order
 | 
	
		
			
				|  |  | + * if param is present in menu , params will be removed from wifi page automatically
 | 
	
		
			
				|  |  | + * eg.
 | 
	
		
			
				|  |  | + *  const char * menu[] = {"wifi","setup","sep","info","exit"};
 | 
	
		
			
				|  |  | + *  WiFiManager.setMenu(menu);
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @param uint8_t menu[] array of menu ids
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setMenu(const char * menu[], uint8_t size){
 | 
	
		
			
				|  |  | +  // DEBUG_WM(DEBUG_VERBOSE,"setmenu array");
 | 
	
		
			
				|  |  | +  _menuIds.clear();
 | 
	
		
			
				|  |  | +  for(size_t i = 0; i < size; i++){
 | 
	
		
			
				|  |  | +    for(size_t j = 0; j < _nummenutokens; j++){
 | 
	
		
			
				|  |  | +      if(menu[i] == _menutokens[j]){
 | 
	
		
			
				|  |  | +        if((String)menu[i] == "param") _paramsInWifi = false; // param auto flag
 | 
	
		
			
				|  |  | +        _menuIds.push_back(j);
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  DEBUG_WM(getMenuOut());
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * setMenu with vector
 | 
	
		
			
				|  |  | + * eg.
 | 
	
		
			
				|  |  | + * std::vector<const char *> menu = {"wifi","setup","sep","info","exit"};
 | 
	
		
			
				|  |  | + * WiFiManager.setMenu(menu);
 | 
	
		
			
				|  |  | + * tokens can be found in _menutokens array in strings_en.h
 | 
	
		
			
				|  |  | + * @shiftIncrement $dev
 | 
	
		
			
				|  |  | + * @param {[type]} std::vector<const char *>& menu [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setMenu(std::vector<const char *>& menu){
 | 
	
		
			
				|  |  | +  // DEBUG_WM(DEBUG_VERBOSE,"setmenu vector");
 | 
	
		
			
				|  |  | +  _menuIds.clear();
 | 
	
		
			
				|  |  | +  for(auto menuitem : menu ){
 | 
	
		
			
				|  |  | +    for(size_t j = 0; j < _nummenutokens; j++){
 | 
	
		
			
				|  |  | +      if(menuitem == _menutokens[j]){
 | 
	
		
			
				|  |  | +        if((String)menuitem == "param") _paramsInWifi = false; // param auto flag
 | 
	
		
			
				|  |  | +        _menuIds.push_back(j);
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  DEBUG_WM(getMenuOut());
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * set params as sperate page not in wifi
 | 
	
		
			
				|  |  | + * NOT COMPATIBLE WITH setMenu! @todo scan menuids and insert param after wifi or something
 | 
	
		
			
				|  |  | + * @param bool enable 
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setParamsPage(bool enable){
 | 
	
		
			
				|  |  | +  _paramsInWifi  = !enable;
 | 
	
		
			
				|  |  | +  setMenu(enable ? _menuIdsParams : _menuIdsDefault);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// GETTERS
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * get config portal AP SSID
 | 
	
		
			
				|  |  | + * @since 0.0.1
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @return String the configportal ap name
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +String WiFiManager::getConfigPortalSSID() {
 | 
	
		
			
				|  |  | +  return _apName;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * return the last known connection result
 | 
	
		
			
				|  |  | + * logged on autoconnect and wifisave, can be used to check why failed
 | 
	
		
			
				|  |  | + * get as readable string with getWLStatusString(getLastConxResult);
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @return bool return wl_status codes
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +uint8_t WiFiManager::getLastConxResult(){
 | 
	
		
			
				|  |  | +  return _lastconxresult;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * check if wifi has a saved ap or not
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @return bool true if a saved ap config exists
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +bool WiFiManager::getWiFiIsSaved(){
 | 
	
		
			
				|  |  | +  return WiFi_hasAutoConnect();
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +String WiFiManager::getDefaultAPName(){
 | 
	
		
			
				|  |  | +  String hostString = String(WIFI_getChipId(),HEX);
 | 
	
		
			
				|  |  | +  hostString.toUpperCase();
 | 
	
		
			
				|  |  | +  // char hostString[16] = {0};
 | 
	
		
			
				|  |  | +  // sprintf(hostString, "%06X", ESP.getChipId());  
 | 
	
		
			
				|  |  | +  return _wifissidprefix + "_" + hostString;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * setCountry
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @param String cc country code, must be defined in WiFiSetCountry, US, JP, CN
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setCountry(String cc){
 | 
	
		
			
				|  |  | +  _wificountry = cc;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * setClass
 | 
	
		
			
				|  |  | + * @param String str body class string
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::setClass(String str){
 | 
	
		
			
				|  |  | +  _bodyClass = str;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// HELPERS
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * getWiFiSSID
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @param bool persistent
 | 
	
		
			
				|  |  | + * @return String
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +String WiFiManager::getWiFiSSID(bool persistent){
 | 
	
		
			
				|  |  | +  return WiFi_SSID(persistent);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * getWiFiPass
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @param bool persistent
 | 
	
		
			
				|  |  | + * @return String
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +String WiFiManager::getWiFiPass(bool persistent){
 | 
	
		
			
				|  |  | +  return WiFi_psk(persistent);
 | 
	
		
			
				|  |  | +} 
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// DEBUG
 | 
	
		
			
				|  |  | +// @todo fix DEBUG_WM(0,0);
 | 
	
		
			
				|  |  | +template <typename Generic>
 | 
	
		
			
				|  |  | +void WiFiManager::DEBUG_WM(Generic text) {
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_NOTIFY,text,"");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +template <typename Generic>
 | 
	
		
			
				|  |  | +void WiFiManager::DEBUG_WM(wm_debuglevel_t level,Generic text) {
 | 
	
		
			
				|  |  | +  if(_debugLevel >= level) DEBUG_WM(level,text,"");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +template <typename Generic, typename Genericb>
 | 
	
		
			
				|  |  | +void WiFiManager::DEBUG_WM(Generic text,Genericb textb) {
 | 
	
		
			
				|  |  | +  DEBUG_WM(DEBUG_NOTIFY,text,textb);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +template <typename Generic, typename Genericb>
 | 
	
		
			
				|  |  | +void WiFiManager::DEBUG_WM(wm_debuglevel_t level,Generic text,Genericb textb) {
 | 
	
		
			
				|  |  | +  if(!_debug || _debugLevel < level) return;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if(_debugLevel >= DEBUG_MAX){
 | 
	
		
			
				|  |  | +    uint32_t free;
 | 
	
		
			
				|  |  | +    uint16_t max;
 | 
	
		
			
				|  |  | +    uint8_t frag;
 | 
	
		
			
				|  |  | +    #ifdef ESP8266
 | 
	
		
			
				|  |  | +    ESP.getHeapStats(&free, &max, &frag);
 | 
	
		
			
				|  |  | +    _debugPort.printf("[MEM] free: %5d | max: %5d | frag: %3d%% \n", free, max, frag);
 | 
	
		
			
				|  |  | +    #elif defined ESP32
 | 
	
		
			
				|  |  | +    // total_free_bytes;      ///<  Total free bytes in the heap. Equivalent to multi_free_heap_size().
 | 
	
		
			
				|  |  | +    // total_allocated_bytes; ///<  Total bytes allocated to data in the heap.
 | 
	
		
			
				|  |  | +    // largest_free_block;    ///<  Size of largest free block in the heap. This is the largest malloc-able size.
 | 
	
		
			
				|  |  | +    // minimum_free_bytes;    ///<  Lifetime minimum free heap size. Equivalent to multi_minimum_free_heap_size().
 | 
	
		
			
				|  |  | +    // allocated_blocks;      ///<  Number of (variable size) blocks allocated in the heap.
 | 
	
		
			
				|  |  | +    // free_blocks;           ///<  Number of (variable size) free blocks in the heap.
 | 
	
		
			
				|  |  | +    // total_blocks;          ///<  Total number of (variable size) blocks in the heap.
 | 
	
		
			
				|  |  | +    multi_heap_info_t info;
 | 
	
		
			
				|  |  | +    heap_caps_get_info(&info, MALLOC_CAP_INTERNAL);
 | 
	
		
			
				|  |  | +    free = info.total_free_bytes;
 | 
	
		
			
				|  |  | +    max  = info.largest_free_block;
 | 
	
		
			
				|  |  | +    frag = 100 - (max * 100) / free;
 | 
	
		
			
				|  |  | +    _debugPort.printf("[MEM] free: %5d | max: %5d | frag: %3d%% \n", free, max, frag);    
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  _debugPort.print("*WM: ");
 | 
	
		
			
				|  |  | +  if(_debugLevel == DEBUG_DEV) _debugPort.print("["+(String)level+"] ");
 | 
	
		
			
				|  |  | +  _debugPort.print(text);
 | 
	
		
			
				|  |  | +  if(textb){
 | 
	
		
			
				|  |  | +    _debugPort.print(" ");
 | 
	
		
			
				|  |  | +    _debugPort.print(textb);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  _debugPort.println();
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [debugSoftAPConfig description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @return {[type]} [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::debugSoftAPConfig(){
 | 
	
		
			
				|  |  | +    wifi_country_t country;
 | 
	
		
			
				|  |  | +    
 | 
	
		
			
				|  |  | +    #ifdef ESP8266
 | 
	
		
			
				|  |  | +      softap_config config;
 | 
	
		
			
				|  |  | +      wifi_softap_get_config(&config);
 | 
	
		
			
				|  |  | +      wifi_get_country(&country);
 | 
	
		
			
				|  |  | +    #elif defined(ESP32)
 | 
	
		
			
				|  |  | +      wifi_config_t conf_config;
 | 
	
		
			
				|  |  | +      esp_wifi_get_config(WIFI_IF_AP, &conf_config); // == ESP_OK
 | 
	
		
			
				|  |  | +      wifi_ap_config_t config = conf_config.ap;
 | 
	
		
			
				|  |  | +      esp_wifi_get_country(&country);
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("SoftAP Configuration"));
 | 
	
		
			
				|  |  | +    DEBUG_WM(FPSTR(D_HR));
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("ssid:            "),(char *) config.ssid);
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("password:        "),(char *) config.password);
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("ssid_len:        "),config.ssid_len);
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("channel:         "),config.channel);
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("authmode:        "),config.authmode);
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("ssid_hidden:     "),config.ssid_hidden);
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("max_connection:  "),config.max_connection);
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("country:         "),(String)country.cc);
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("beacon_interval: "),(String)config.beacon_interval + "(ms)");
 | 
	
		
			
				|  |  | +    DEBUG_WM(FPSTR(D_HR));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [debugPlatformInfo description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @return {[type]} [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +void WiFiManager::debugPlatformInfo(){
 | 
	
		
			
				|  |  | +  #ifdef ESP8266
 | 
	
		
			
				|  |  | +    system_print_meminfo();
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("getCoreVersion():         "),ESP.getCoreVersion());
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("system_get_sdk_version(): "),system_get_sdk_version());
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("system_get_boot_version():"),system_get_boot_version());
 | 
	
		
			
				|  |  | +    DEBUG_WM(F("getFreeHeap():            "),(String)ESP.getFreeHeap());
 | 
	
		
			
				|  |  | +  #elif defined(ESP32)
 | 
	
		
			
				|  |  | +    size_t freeHeap = heap_caps_get_free_size(MALLOC_CAP_8BIT);
 | 
	
		
			
				|  |  | +    DEBUG_WM("Free heap:       ", freeHeap);
 | 
	
		
			
				|  |  | +    DEBUG_WM("ESP-IDF version: ", esp_get_idf_version());
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +int WiFiManager::getRSSIasQuality(int RSSI) {
 | 
	
		
			
				|  |  | +  int quality = 0;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  if (RSSI <= -100) {
 | 
	
		
			
				|  |  | +    quality = 0;
 | 
	
		
			
				|  |  | +  } else if (RSSI >= -50) {
 | 
	
		
			
				|  |  | +    quality = 100;
 | 
	
		
			
				|  |  | +  } else {
 | 
	
		
			
				|  |  | +    quality = 2 * (RSSI + 100);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return quality;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/** Is this an IP? */
 | 
	
		
			
				|  |  | +boolean WiFiManager::isIp(String str) {
 | 
	
		
			
				|  |  | +  for (size_t i = 0; i < str.length(); i++) {
 | 
	
		
			
				|  |  | +    int c = str.charAt(i);
 | 
	
		
			
				|  |  | +    if (c != '.' && (c < '0' || c > '9')) {
 | 
	
		
			
				|  |  | +      return false;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return true;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/** IP to String? */
 | 
	
		
			
				|  |  | +String WiFiManager::toStringIp(IPAddress ip) {
 | 
	
		
			
				|  |  | +  String res = "";
 | 
	
		
			
				|  |  | +  for (int i = 0; i < 3; i++) {
 | 
	
		
			
				|  |  | +    res += String((ip >> (8 * i)) & 0xFF) + ".";
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  res += String(((ip >> 8 * 3)) & 0xFF);
 | 
	
		
			
				|  |  | +  return res;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +boolean WiFiManager::validApPassword(){
 | 
	
		
			
				|  |  | +  // check that ap password is valid, return false
 | 
	
		
			
				|  |  | +  if (_apPassword == NULL) _apPassword = "";
 | 
	
		
			
				|  |  | +  if (_apPassword != "") {
 | 
	
		
			
				|  |  | +    if (_apPassword.length() < 8 || _apPassword.length() > 63) {
 | 
	
		
			
				|  |  | +      DEBUG_WM(F("AccessPoint set password is INVALID or <8 chars"));
 | 
	
		
			
				|  |  | +      _apPassword = "";
 | 
	
		
			
				|  |  | +      return false; // @todo FATAL or fallback to empty ?
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_VERBOSE,F("AccessPoint set password is VALID"));
 | 
	
		
			
				|  |  | +    DEBUG_WM(_apPassword);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return true;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * encode htmlentities
 | 
	
		
			
				|  |  | + * @since $dev
 | 
	
		
			
				|  |  | + * @param  string str  string to replace entities
 | 
	
		
			
				|  |  | + * @return string      encoded string
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +String WiFiManager::htmlEntities(String str) {
 | 
	
		
			
				|  |  | +  str.replace("&","&");
 | 
	
		
			
				|  |  | +  str.replace("<","<");
 | 
	
		
			
				|  |  | +  str.replace(">",">");
 | 
	
		
			
				|  |  | +  // str.replace("'","'");
 | 
	
		
			
				|  |  | +  // str.replace("\"",""");
 | 
	
		
			
				|  |  | +  // str.replace("/": "/");
 | 
	
		
			
				|  |  | +  // str.replace("`": "`");
 | 
	
		
			
				|  |  | +  // str.replace("=": "=");
 | 
	
		
			
				|  |  | +return str;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * [getWLStatusString description]
 | 
	
		
			
				|  |  | + * @access public
 | 
	
		
			
				|  |  | + * @param  {[type]} uint8_t status        [description]
 | 
	
		
			
				|  |  | + * @return {[type]}         [description]
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +String WiFiManager::getWLStatusString(uint8_t status){
 | 
	
		
			
				|  |  | +  if(status <= 7) return WIFI_STA_STATUS[status];
 | 
	
		
			
				|  |  | +  return FPSTR(S_NA);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +String WiFiManager::encryptionTypeStr(uint8_t authmode) {
 | 
	
		
			
				|  |  | +  // DEBUG_WM("enc_tye: ",authmode);
 | 
	
		
			
				|  |  | +  return AUTH_MODE_NAMES[authmode];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +String WiFiManager::getModeString(uint8_t mode){
 | 
	
		
			
				|  |  | +  if(mode <= 3) return WIFI_MODES[mode];
 | 
	
		
			
				|  |  | +  return FPSTR(S_NA);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +bool WiFiManager::WiFiSetCountry(){
 | 
	
		
			
				|  |  | +  if(_wificountry == "") return false; // skip not set
 | 
	
		
			
				|  |  | +  bool ret = false;
 | 
	
		
			
				|  |  | +  #ifdef ESP32
 | 
	
		
			
				|  |  | +  // @todo check if wifi is init, no idea how, doesnt seem to be exposed atm ( might be now! )
 | 
	
		
			
				|  |  | +       if(WiFi.getMode() == WIFI_MODE_NULL); // exception if wifi not init!
 | 
	
		
			
				|  |  | +  else if(_wificountry == "US") ret = esp_wifi_set_country(&WM_COUNTRY_US) == ESP_OK;
 | 
	
		
			
				|  |  | +  else if(_wificountry == "JP") ret = esp_wifi_set_country(&WM_COUNTRY_JP) == ESP_OK;
 | 
	
		
			
				|  |  | +  else if(_wificountry == "CN") ret = esp_wifi_set_country(&WM_COUNTRY_CN) == ESP_OK;
 | 
	
		
			
				|  |  | +  else DEBUG_WM(DEBUG_ERROR,"[ERROR] country code not found");
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  #elif defined(ESP8266)
 | 
	
		
			
				|  |  | +       // if(WiFi.getMode() == WIFI_OFF); // exception if wifi not init!
 | 
	
		
			
				|  |  | +       if(_wificountry == "US") ret = wifi_set_country((wifi_country_t*)&WM_COUNTRY_US);
 | 
	
		
			
				|  |  | +  else if(_wificountry == "JP") ret = wifi_set_country((wifi_country_t*)&WM_COUNTRY_JP);
 | 
	
		
			
				|  |  | +  else if(_wificountry == "CN") ret = wifi_set_country((wifi_country_t*)&WM_COUNTRY_CN);
 | 
	
		
			
				|  |  | +  else DEBUG_WM(DEBUG_ERROR,"[ERROR] country code not found");
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +  
 | 
	
		
			
				|  |  | +  if(ret) DEBUG_WM(DEBUG_VERBOSE,"esp_wifi_set_country: " + _wificountry);
 | 
	
		
			
				|  |  | +  else DEBUG_WM(DEBUG_ERROR,"[ERROR] esp_wifi_set_country failed");  
 | 
	
		
			
				|  |  | +  return ret;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// set mode ignores WiFi.persistent 
 | 
	
		
			
				|  |  | +bool WiFiManager::WiFi_Mode(WiFiMode_t m,bool persistent) {
 | 
	
		
			
				|  |  | +    bool ret;
 | 
	
		
			
				|  |  | +    #ifdef ESP8266
 | 
	
		
			
				|  |  | +      if((wifi_get_opmode() == (uint8) m ) && !persistent) {
 | 
	
		
			
				|  |  | +          return true;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      ETS_UART_INTR_DISABLE();
 | 
	
		
			
				|  |  | +      if(persistent) ret = wifi_set_opmode(m);
 | 
	
		
			
				|  |  | +      else ret = wifi_set_opmode_current(m);
 | 
	
		
			
				|  |  | +      ETS_UART_INTR_ENABLE();
 | 
	
		
			
				|  |  | +    return ret;
 | 
	
		
			
				|  |  | +    #elif defined(ESP32)
 | 
	
		
			
				|  |  | +      if(persistent && esp32persistent) WiFi.persistent(true);
 | 
	
		
			
				|  |  | +      ret = WiFi.mode(m); // @todo persistent check persistant mode , NI
 | 
	
		
			
				|  |  | +      if(persistent && esp32persistent) WiFi.persistent(false);
 | 
	
		
			
				|  |  | +      return ret;
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +bool WiFiManager::WiFi_Mode(WiFiMode_t m) {
 | 
	
		
			
				|  |  | +	return WiFi_Mode(m,false);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// sta disconnect without persistent
 | 
	
		
			
				|  |  | +bool WiFiManager::WiFi_Disconnect() {
 | 
	
		
			
				|  |  | +    #ifdef ESP8266
 | 
	
		
			
				|  |  | +      if((WiFi.getMode() & WIFI_STA) != 0) {
 | 
	
		
			
				|  |  | +          bool ret;
 | 
	
		
			
				|  |  | +          DEBUG_WM(DEBUG_DEV,F("WIFI station disconnect"));
 | 
	
		
			
				|  |  | +          ETS_UART_INTR_DISABLE(); // @todo probably not needed
 | 
	
		
			
				|  |  | +          ret = wifi_station_disconnect();
 | 
	
		
			
				|  |  | +          ETS_UART_INTR_ENABLE();        
 | 
	
		
			
				|  |  | +          return ret;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    #elif defined(ESP32)
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_DEV,F("WIFI station disconnect"));
 | 
	
		
			
				|  |  | +      return WiFi.disconnect(); // not persistent atm
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +    return false;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// toggle STA without persistent
 | 
	
		
			
				|  |  | +bool WiFiManager::WiFi_enableSTA(bool enable,bool persistent) {
 | 
	
		
			
				|  |  | +    DEBUG_WM(DEBUG_DEV,F("WiFi station enable"));
 | 
	
		
			
				|  |  | +    #ifdef ESP8266
 | 
	
		
			
				|  |  | +      WiFiMode_t newMode;
 | 
	
		
			
				|  |  | +      WiFiMode_t currentMode = WiFi.getMode();
 | 
	
		
			
				|  |  | +      bool isEnabled         = (currentMode & WIFI_STA) != 0;
 | 
	
		
			
				|  |  | +      if(enable) newMode     = (WiFiMode_t)(currentMode | WIFI_STA);
 | 
	
		
			
				|  |  | +      else newMode           = (WiFiMode_t)(currentMode & (~WIFI_STA));
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if((isEnabled != enable) || persistent) {
 | 
	
		
			
				|  |  | +          if(enable) {
 | 
	
		
			
				|  |  | +          	if(persistent) DEBUG_WM(DEBUG_DEV,F("enableSTA PERSISTENT ON"));
 | 
	
		
			
				|  |  | +              return WiFi_Mode(newMode,persistent);
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          else {
 | 
	
		
			
				|  |  | +              return WiFi_Mode(newMode,persistent);
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +          return true;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    #elif defined(ESP32)
 | 
	
		
			
				|  |  | +      bool ret;
 | 
	
		
			
				|  |  | +      if(persistent && esp32persistent) WiFi.persistent(true);
 | 
	
		
			
				|  |  | +      ret =  WiFi.enableSTA(enable); // @todo handle persistent when it is implemented in platform
 | 
	
		
			
				|  |  | +      if(persistent && esp32persistent) WiFi.persistent(false);
 | 
	
		
			
				|  |  | +      return ret;
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +bool WiFiManager::WiFi_enableSTA(bool enable) {
 | 
	
		
			
				|  |  | +	return WiFi_enableSTA(enable,false);
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +bool WiFiManager::WiFi_eraseConfig() {
 | 
	
		
			
				|  |  | +    #ifdef ESP8266
 | 
	
		
			
				|  |  | +      #ifndef WM_FIXERASECONFIG 
 | 
	
		
			
				|  |  | +        return ESP.eraseConfig();
 | 
	
		
			
				|  |  | +      #else
 | 
	
		
			
				|  |  | +        // erase config BUG replacement
 | 
	
		
			
				|  |  | +        // https://github.com/esp8266/Arduino/pull/3635
 | 
	
		
			
				|  |  | +        const size_t cfgSize = 0x4000;
 | 
	
		
			
				|  |  | +        size_t cfgAddr = ESP.getFlashChipSize() - cfgSize;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        for (size_t offset = 0; offset < cfgSize; offset += SPI_FLASH_SEC_SIZE) {
 | 
	
		
			
				|  |  | +            if (!ESP.flashEraseSector((cfgAddr + offset) / SPI_FLASH_SEC_SIZE)) {
 | 
	
		
			
				|  |  | +                return false;
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        return true;
 | 
	
		
			
				|  |  | +      #endif
 | 
	
		
			
				|  |  | +    #elif defined(ESP32)
 | 
	
		
			
				|  |  | +      bool ret;
 | 
	
		
			
				|  |  | +      WiFi.mode(WIFI_AP_STA); // cannot erase if not in STA mode !
 | 
	
		
			
				|  |  | +      WiFi.persistent(true);
 | 
	
		
			
				|  |  | +      ret = WiFi.disconnect(true,true);
 | 
	
		
			
				|  |  | +      WiFi.persistent(false);
 | 
	
		
			
				|  |  | +      return ret;
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +uint8_t WiFiManager::WiFi_softap_num_stations(){
 | 
	
		
			
				|  |  | +  #ifdef ESP8266
 | 
	
		
			
				|  |  | +    return wifi_softap_get_station_num();
 | 
	
		
			
				|  |  | +  #elif defined(ESP32)
 | 
	
		
			
				|  |  | +    return WiFi.softAPgetStationNum();
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +bool WiFiManager::WiFi_hasAutoConnect(){
 | 
	
		
			
				|  |  | +  return WiFi_SSID(true) != "";
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +String WiFiManager::WiFi_SSID(bool persistent) const{
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    #ifdef ESP8266
 | 
	
		
			
				|  |  | +    struct station_config conf;
 | 
	
		
			
				|  |  | +    if(persistent) wifi_station_get_config_default(&conf);
 | 
	
		
			
				|  |  | +    else wifi_station_get_config(&conf);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    char tmp[33]; //ssid can be up to 32chars, => plus null term
 | 
	
		
			
				|  |  | +    memcpy(tmp, conf.ssid, sizeof(conf.ssid));
 | 
	
		
			
				|  |  | +    tmp[32] = 0; //nullterm in case of 32 char ssid
 | 
	
		
			
				|  |  | +    return String(reinterpret_cast<char*>(tmp));
 | 
	
		
			
				|  |  | +    
 | 
	
		
			
				|  |  | +    #elif defined(ESP32)
 | 
	
		
			
				|  |  | +    if(persistent){
 | 
	
		
			
				|  |  | +      wifi_config_t conf;
 | 
	
		
			
				|  |  | +      esp_wifi_get_config(WIFI_IF_STA, &conf);
 | 
	
		
			
				|  |  | +      return String(reinterpret_cast<const char*>(conf.sta.ssid));
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    else {
 | 
	
		
			
				|  |  | +      if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){
 | 
	
		
			
				|  |  | +          return String();
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      wifi_ap_record_t info;
 | 
	
		
			
				|  |  | +      if(!esp_wifi_sta_get_ap_info(&info)) {
 | 
	
		
			
				|  |  | +          return String(reinterpret_cast<char*>(info.ssid));
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      return String();
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +String WiFiManager::WiFi_psk(bool persistent) const {
 | 
	
		
			
				|  |  | +    #ifdef ESP8266
 | 
	
		
			
				|  |  | +    struct station_config conf;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    if(persistent) wifi_station_get_config_default(&conf);
 | 
	
		
			
				|  |  | +    else wifi_station_get_config(&conf);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    char tmp[65]; //psk is 64 bytes hex => plus null term
 | 
	
		
			
				|  |  | +    memcpy(tmp, conf.password, sizeof(conf.password));
 | 
	
		
			
				|  |  | +    tmp[64] = 0; //null term in case of 64 byte psk
 | 
	
		
			
				|  |  | +    return String(reinterpret_cast<char*>(tmp));
 | 
	
		
			
				|  |  | +    
 | 
	
		
			
				|  |  | +    #elif defined(ESP32)
 | 
	
		
			
				|  |  | +    // only if wifi is init
 | 
	
		
			
				|  |  | +    if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){
 | 
	
		
			
				|  |  | +      return String();
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    wifi_config_t conf;
 | 
	
		
			
				|  |  | +    esp_wifi_get_config(WIFI_IF_STA, &conf);
 | 
	
		
			
				|  |  | +    return String(reinterpret_cast<char*>(conf.sta.password));
 | 
	
		
			
				|  |  | +    #endif
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +#ifdef ESP32
 | 
	
		
			
				|  |  | +void WiFiManager::WiFiEvent(WiFiEvent_t event,system_event_info_t info){
 | 
	
		
			
				|  |  | +    if(!_hasBegun){
 | 
	
		
			
				|  |  | +      // DEBUG_WM(DEBUG_VERBOSE,"[ERROR] WiFiEvent, not ready");
 | 
	
		
			
				|  |  | +      return;
 | 
	
		
			
				|  |  | +    } 
 | 
	
		
			
				|  |  | +    // DEBUG_WM(DEBUG_VERBOSE,"[EVENT]",event);
 | 
	
		
			
				|  |  | +    if(event == SYSTEM_EVENT_STA_DISCONNECTED){
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_VERBOSE,"[EVENT] WIFI_REASON:",info.disconnected.reason);
 | 
	
		
			
				|  |  | +      if(info.disconnected.reason == WIFI_REASON_AUTH_EXPIRE || info.disconnected.reason == WIFI_REASON_AUTH_FAIL){
 | 
	
		
			
				|  |  | +        _lastconxresulttmp = 7; // hack in wrong password internally, sdk emit WIFI_REASON_AUTH_EXPIRE on some routers on auth_fail
 | 
	
		
			
				|  |  | +      } else _lastconxresulttmp = WiFi.status();
 | 
	
		
			
				|  |  | +      if(info.disconnected.reason == WIFI_REASON_NO_AP_FOUND) DEBUG_WM(DEBUG_VERBOSE,"[EVENT] WIFI_REASON: NO_AP_FOUND");
 | 
	
		
			
				|  |  | +      #ifdef esp32autoreconnect
 | 
	
		
			
				|  |  | +        DEBUG_WM(DEBUG_VERBOSE,"[Event] SYSTEM_EVENT_STA_DISCONNECTED, reconnecting");
 | 
	
		
			
				|  |  | +        WiFi.reconnect();
 | 
	
		
			
				|  |  | +      #endif
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  else if(event == SYSTEM_EVENT_SCAN_DONE){
 | 
	
		
			
				|  |  | +    uint16_t scans = WiFi.scanComplete();
 | 
	
		
			
				|  |  | +    WiFi_scanComplete(scans);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +#endif
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +void WiFiManager::WiFi_autoReconnect(){
 | 
	
		
			
				|  |  | +  #ifdef ESP8266
 | 
	
		
			
				|  |  | +    WiFi.setAutoReconnect(_wifiAutoReconnect);
 | 
	
		
			
				|  |  | +  #elif defined(ESP32)
 | 
	
		
			
				|  |  | +    // if(_wifiAutoReconnect){
 | 
	
		
			
				|  |  | +      // @todo move to seperate method, used for event listener now
 | 
	
		
			
				|  |  | +      DEBUG_WM(DEBUG_VERBOSE,"ESP32 event handler enabled");
 | 
	
		
			
				|  |  | +      using namespace std::placeholders;
 | 
	
		
			
				|  |  | +      WiFi.onEvent(std::bind(&WiFiManager::WiFiEvent,this,_1,_2));
 | 
	
		
			
				|  |  | +    // }
 | 
	
		
			
				|  |  | +  #endif
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +#endif
 |