fix(prov): Use network_provisioning

Author: me-no-dev

CMakeLists.txt

@@ -293,7 +293,7 @@ endforeach()
 set(includedirs variants/${CONFIG_ARDUINO_VARIANT}/ cores/esp32/ ${ARDUINO_LIBRARIES_INCLUDEDIRS})
 set(srcs ${CORE_SRCS} ${ARDUINO_LIBRARIES_SRCS})
 set(priv_includes cores/esp32/libb64)
-set(requires spi_flash esp_partition mbedtls wifi_provisioning wpa_supplicant esp_adc esp_eth http_parser)
+set(requires spi_flash esp_partition mbedtls wpa_supplicant esp_adc esp_eth http_parser espressif__network_provisioning)
 set(priv_requires fatfs nvs_flash app_update spiffs bootloader_support bt esp_hid usb esp_psram ${ARDUINO_LIBRARIES_REQUIRES})
 
 if(NOT CONFIG_ARDUINO_SELECTIVE_COMPILATION OR CONFIG_ARDUINO_SELECTIVE_OpenThread)

libraries/Network/src/NetworkEvents.h

@@ -20,7 +20,7 @@
 #if SOC_WIFI_SUPPORTED
 #include "esp_wifi_types.h"
 #include "esp_smartconfig.h"
-#include "wifi_provisioning/wifi_config.h"
+#include "network_provisioning/network_config.h"
 #endif
 
 #if SOC_WIFI_SUPPORTED
@@ -105,7 +105,7 @@ typedef union {
   wifi_event_ap_stadisconnected_t wifi_ap_stadisconnected;
   wifi_event_ftm_report_t wifi_ftm_report;
   wifi_sta_config_t prov_cred_recv;
-  wifi_prov_sta_fail_reason_t prov_fail_reason;
+  network_prov_wifi_sta_fail_reason_t prov_fail_reason;
   smartconfig_event_got_ssid_pswd_t sc_got_ssid_pswd;
 #endif
 } arduino_event_info_t;

libraries/RainMaker/examples/RMakerCustom/RMakerCustom.ino

@@ -101,9 +101,9 @@ void setup() {
 
   WiFi.onEvent(sysProvEvent);  // Will call sysProvEvent() from another thread.
 #if CONFIG_IDF_TARGET_ESP32S2
-  WiFiProv.beginProvision(WIFI_PROV_SCHEME_SOFTAP, WIFI_PROV_SCHEME_HANDLER_NONE, WIFI_PROV_SECURITY_1, pop, service_name);
+  WiFiProv.beginProvision(NETWORK_PROV_SCHEME_SOFTAP, NETWORK_PROV_SCHEME_HANDLER_NONE, NETWORK_PROV_SECURITY_1, pop, service_name);
 #else
-  WiFiProv.beginProvision(WIFI_PROV_SCHEME_BLE, WIFI_PROV_SCHEME_HANDLER_FREE_BTDM, WIFI_PROV_SECURITY_1, pop, service_name);
+  WiFiProv.beginProvision(NETWORK_PROV_SCHEME_BLE, NETWORK_PROV_SCHEME_HANDLER_FREE_BTDM, NETWORK_PROV_SECURITY_1, pop, service_name);
 #endif
 }
 

libraries/RainMaker/examples/RMakerCustomAirCooler/RMakerCustomAirCooler.ino

@@ -166,9 +166,9 @@ void setup() {
 
   WiFi.onEvent(sysProvEvent);  // Will call sysProvEvent() from another thread.
 #if CONFIG_IDF_TARGET_ESP32S2
-  WiFiProv.beginProvision(WIFI_PROV_SCHEME_SOFTAP, WIFI_PROV_SCHEME_HANDLER_NONE, WIFI_PROV_SECURITY_1, pop, service_name);
+  WiFiProv.beginProvision(NETWORK_PROV_SCHEME_SOFTAP, NETWORK_PROV_SCHEME_HANDLER_NONE, NETWORK_PROV_SECURITY_1, pop, service_name);
 #else
-  WiFiProv.beginProvision(WIFI_PROV_SCHEME_BLE, WIFI_PROV_SCHEME_HANDLER_FREE_BTDM, WIFI_PROV_SECURITY_1, pop, service_name);
+  WiFiProv.beginProvision(NETWORK_PROV_SCHEME_BLE, NETWORK_PROV_SCHEME_HANDLER_FREE_BTDM, NETWORK_PROV_SECURITY_1, pop, service_name);
 #endif
 }
 

libraries/RainMaker/examples/RMakerSonoffDualR3/RMakerSonoffDualR3.ino

@@ -151,9 +151,9 @@ void setup() {
 
   WiFi.onEvent(sysProvEvent);  // Will call sysProvEvent() from another thread.
 #if CONFIG_IDF_TARGET_ESP32
-  WiFiProv.beginProvision(WIFI_PROV_SCHEME_BLE, WIFI_PROV_SCHEME_HANDLER_FREE_BTDM, WIFI_PROV_SECURITY_1, pop, service_name);
+  WiFiProv.beginProvision(NETWORK_PROV_SCHEME_BLE, NETWORK_PROV_SCHEME_HANDLER_FREE_BTDM, NETWORK_PROV_SECURITY_1, pop, service_name);
 #else
-  WiFiProv.beginProvision(WIFI_PROV_SCHEME_SOFTAP, WIFI_PROV_SCHEME_HANDLER_NONE, WIFI_PROV_SECURITY_1, pop, service_name);
+  WiFiProv.beginProvision(NETWORK_PROV_SCHEME_SOFTAP, NETWORK_PROV_SCHEME_HANDLER_NONE, NETWORK_PROV_SECURITY_1, pop, service_name);
 #endif
 }
 

libraries/RainMaker/examples/RMakerSwitch/RMakerSwitch.ino

@@ -98,9 +98,9 @@ void setup() {
 
   WiFi.onEvent(sysProvEvent);  // Will call sysProvEvent() from another thread.
 #if CONFIG_IDF_TARGET_ESP32S2
-  WiFiProv.beginProvision(WIFI_PROV_SCHEME_SOFTAP, WIFI_PROV_SCHEME_HANDLER_NONE, WIFI_PROV_SECURITY_1, pop, service_name);
+  WiFiProv.beginProvision(NETWORK_PROV_SCHEME_SOFTAP, NETWORK_PROV_SCHEME_HANDLER_NONE, NETWORK_PROV_SECURITY_1, pop, service_name);
 #else
-  WiFiProv.beginProvision(WIFI_PROV_SCHEME_BLE, WIFI_PROV_SCHEME_HANDLER_FREE_BTDM, WIFI_PROV_SECURITY_1, pop, service_name);
+  WiFiProv.beginProvision(NETWORK_PROV_SCHEME_BLE, NETWORK_PROV_SCHEME_HANDLER_FREE_BTDM, NETWORK_PROV_SECURITY_1, pop, service_name);
 #endif
 }
 

libraries/WiFi/src/WiFiGeneric.cpp

@@ -126,34 +126,34 @@ static void _arduino_event_cb(void *arg, esp_event_base_t event_base, int32_t ev
     /*
 	 * Provisioning
 	 * */
-  } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_INIT) {
+  } else if (event_base == NETWORK_PROV_EVENT && event_id == NETWORK_PROV_INIT) {
     log_v("Provisioning Initialized!");
     arduino_event.event_id = ARDUINO_EVENT_PROV_INIT;
-  } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_DEINIT) {
+  } else if (event_base == NETWORK_PROV_EVENT && event_id == NETWORK_PROV_DEINIT) {
     log_v("Provisioning Uninitialized!");
     arduino_event.event_id = ARDUINO_EVENT_PROV_DEINIT;
-  } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_START) {
+  } else if (event_base == NETWORK_PROV_EVENT && event_id == NETWORK_PROV_START) {
     log_v("Provisioning Start!");
     arduino_event.event_id = ARDUINO_EVENT_PROV_START;
-  } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_END) {
+  } else if (event_base == NETWORK_PROV_EVENT && event_id == NETWORK_PROV_END) {
     log_v("Provisioning End!");
-    wifi_prov_mgr_deinit();
+    network_prov_mgr_deinit();
     arduino_event.event_id = ARDUINO_EVENT_PROV_END;
-  } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_CRED_RECV) {
+  } else if (event_base == NETWORK_PROV_EVENT && event_id == NETWORK_PROV_WIFI_CRED_RECV) {
 #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_VERBOSE
     wifi_sta_config_t *event = (wifi_sta_config_t *)event_data;
     log_v("Provisioned Credentials: SSID: %s, Password: %s", (const char *)event->ssid, (const char *)event->password);
 #endif
     arduino_event.event_id = ARDUINO_EVENT_PROV_CRED_RECV;
     memcpy(&arduino_event.event_info.prov_cred_recv, event_data, sizeof(wifi_sta_config_t));
-  } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_CRED_FAIL) {
+  } else if (event_base == NETWORK_PROV_EVENT && event_id == NETWORK_PROV_WIFI_CRED_FAIL) {
 #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_ERROR
-    wifi_prov_sta_fail_reason_t *reason = (wifi_prov_sta_fail_reason_t *)event_data;
-    log_e("Provisioning Failed: Reason : %s", (*reason == WIFI_PROV_STA_AUTH_ERROR) ? "Authentication Failed" : "AP Not Found");
+    network_prov_wifi_sta_fail_reason_t *reason = (network_prov_wifi_sta_fail_reason_t *)event_data;
+    log_e("Provisioning Failed: Reason : %s", (*reason == NETWORK_PROV_WIFI_STA_AUTH_ERROR) ? "Authentication Failed" : "AP Not Found");
 #endif
     arduino_event.event_id = ARDUINO_EVENT_PROV_CRED_FAIL;
-    memcpy(&arduino_event.event_info.prov_fail_reason, event_data, sizeof(wifi_prov_sta_fail_reason_t));
-  } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_CRED_SUCCESS) {
+    memcpy(&arduino_event.event_info.prov_fail_reason, event_data, sizeof(network_prov_wifi_sta_fail_reason_t));
+  } else if (event_base == NETWORK_PROV_EVENT && event_id == NETWORK_PROV_WIFI_CRED_SUCCESS) {
     log_v("Provisioning Success!");
     arduino_event.event_id = ARDUINO_EVENT_PROV_CRED_SUCCESS;
   }
@@ -174,8 +174,8 @@ static bool initWiFiEvents() {
     return false;
   }
 
-  if (esp_event_handler_instance_register(WIFI_PROV_EVENT, ESP_EVENT_ANY_ID, &_arduino_event_cb, NULL, NULL)) {
-    log_e("event_handler_instance_register for WIFI_PROV_EVENT Failed!");
+  if (esp_event_handler_instance_register(NETWORK_PROV_EVENT, ESP_EVENT_ANY_ID, &_arduino_event_cb, NULL, NULL)) {
+    log_e("event_handler_instance_register for NETWORK_PROV_EVENT Failed!");
     return false;
   }
 
@@ -193,8 +193,8 @@ static bool deinitWiFiEvents() {
     return false;
   }
 
-  if (esp_event_handler_unregister(WIFI_PROV_EVENT, ESP_EVENT_ANY_ID, &_arduino_event_cb)) {
-    log_e("esp_event_handler_unregister for WIFI_PROV_EVENT Failed!");
+  if (esp_event_handler_unregister(NETWORK_PROV_EVENT, ESP_EVENT_ANY_ID, &_arduino_event_cb)) {
+    log_e("esp_event_handler_unregister for NETWORK_PROV_EVENT Failed!");
     return false;
   }
 

libraries/WiFi/src/WiFiGeneric.h

@@ -33,7 +33,7 @@
 #include "esp_smartconfig.h"
 #include "esp_netif_types.h"
 #include "esp_eth_driver.h"
-#include "wifi_provisioning/manager.h"
+#include "network_provisioning/manager.h"
 #include "lwip/ip_addr.h"
 
 #include "Network.h"

libraries/WiFiProv/examples/WiFiProv/WiFiProv.ino

@@ -38,7 +38,7 @@ void SysProvEvent(arduino_event_t *sys_event) {
     case ARDUINO_EVENT_PROV_CRED_FAIL:
     {
       Serial.println("\nProvisioning failed!\nPlease reset to factory and retry provisioning\n");
-      if (sys_event->event_info.prov_fail_reason == WIFI_PROV_STA_AUTH_ERROR) {
+      if (sys_event->event_info.prov_fail_reason == NETWORK_PROV_STA_AUTH_ERROR) {
         Serial.println("\nWi-Fi AP password incorrect");
       } else {
         Serial.println("\nWi-Fi AP not found....Add API \" nvs_flash_erase() \" before beginProvision()");
@@ -62,13 +62,13 @@ void setup() {
   // Sample uuid that user can pass during provisioning using BLE
   uint8_t uuid[16] = {0xb4, 0xdf, 0x5a, 0x1c, 0x3f, 0x6b, 0xf4, 0xbf, 0xea, 0x4a, 0x82, 0x03, 0x04, 0x90, 0x1a, 0x02};
   WiFiProv.beginProvision(
-    WIFI_PROV_SCHEME_BLE, WIFI_PROV_SCHEME_HANDLER_FREE_BLE, WIFI_PROV_SECURITY_1, pop, service_name, service_key, uuid, reset_provisioned
+    NETWORK_PROV_SCHEME_BLE, NETWORK_PROV_SCHEME_HANDLER_FREE_BLE, NETWORK_PROV_SECURITY_1, pop, service_name, service_key, uuid, reset_provisioned
   );
   log_d("ble qr");
   WiFiProv.printQR(service_name, pop, "ble");
 #else
   Serial.println("Begin Provisioning using Soft AP");
-  WiFiProv.beginProvision(WIFI_PROV_SCHEME_SOFTAP, WIFI_PROV_SCHEME_HANDLER_NONE, WIFI_PROV_SECURITY_1, pop, service_name, service_key);
+  WiFiProv.beginProvision(NETWORK_PROV_SCHEME_SOFTAP, NETWORK_PROV_SCHEME_HANDLER_NONE, NETWORK_PROV_SECURITY_1, pop, service_name, service_key);
   log_d("wifi qr");
   WiFiProv.printQR(service_name, pop, "softap");
 #endif

libraries/WiFiProv/src/WiFiProv.cpp

@@ -34,10 +34,10 @@
 
 #include <nvs_flash.h>
 #if CONFIG_BLUEDROID_ENABLED
-#include "wifi_provisioning/scheme_ble.h"
+#include "network_provisioning/scheme_ble.h"
 #endif
-#include <wifi_provisioning/scheme_softap.h>
-#include <wifi_provisioning/manager.h>
+#include <network_provisioning/scheme_softap.h>
+#include <network_provisioning/manager.h>
 #undef IPADDR_NONE
 #include "WiFiProv.h"
 #if CONFIG_IDF_TARGET_ESP32
@@ -61,7 +61,7 @@ static void get_device_service_name(prov_scheme_t prov_scheme, char *service_nam
     return;
   }
 #if CONFIG_IDF_TARGET_ESP32 && defined(CONFIG_BLUEDROID_ENABLED)
-  if (prov_scheme == WIFI_PROV_SCHEME_BLE) {
+  if (prov_scheme == NETWORK_PROV_SCHEME_BLE) {
     snprintf(service_name, max, "%s%02X%02X%02X", SERV_NAME_PREFIX_PROV, eth_mac[3], eth_mac[4], eth_mac[5]);
   } else {
 #endif
@@ -72,36 +72,36 @@ static void get_device_service_name(prov_scheme_t prov_scheme, char *service_nam
 }
 
 void WiFiProvClass ::beginProvision(
-  prov_scheme_t prov_scheme, scheme_handler_t scheme_handler, wifi_prov_security_t security, const char *pop, const char *service_name, const char *service_key,
+  prov_scheme_t prov_scheme, scheme_handler_t scheme_handler, network_prov_security_t security, const char *pop, const char *service_name, const char *service_key,
   uint8_t *uuid, bool reset_provisioned
 ) {
   bool provisioned = false;
   static char service_name_temp[32];
 
-  wifi_prov_mgr_config_t config;
+  network_prov_mgr_config_t config;
 #if CONFIG_BLUEDROID_ENABLED
-  if (prov_scheme == WIFI_PROV_SCHEME_BLE) {
-    config.scheme = wifi_prov_scheme_ble;
+  if (prov_scheme == NETWORK_PROV_SCHEME_BLE) {
+    config.scheme = network_prov_scheme_ble;
   } else {
 #endif
-    config.scheme = wifi_prov_scheme_softap;
+    config.scheme = network_prov_scheme_softap;
 #if CONFIG_BLUEDROID_ENABLED
   }
 
-  if (scheme_handler == WIFI_PROV_SCHEME_HANDLER_NONE) {
+  if (scheme_handler == NETWORK_PROV_SCHEME_HANDLER_NONE) {
 #endif
-    wifi_prov_event_handler_t scheme_event_handler = WIFI_PROV_EVENT_HANDLER_NONE;
-    memcpy(&config.scheme_event_handler, &scheme_event_handler, sizeof(wifi_prov_event_handler_t));
+    network_prov_event_handler_t scheme_event_handler = NETWORK_PROV_EVENT_HANDLER_NONE;
+    memcpy(&config.scheme_event_handler, &scheme_event_handler, sizeof(network_prov_event_handler_t));
 #if CONFIG_BLUEDROID_ENABLED
-  } else if (scheme_handler == WIFI_PROV_SCHEME_HANDLER_FREE_BTDM) {
-    wifi_prov_event_handler_t scheme_event_handler = WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BTDM;
-    memcpy(&config.scheme_event_handler, &scheme_event_handler, sizeof(wifi_prov_event_handler_t));
-  } else if (scheme_handler == WIFI_PROV_SCHEME_HANDLER_FREE_BT) {
-    wifi_prov_event_handler_t scheme_event_handler = WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BT;
-    memcpy(&config.scheme_event_handler, &scheme_event_handler, sizeof(wifi_prov_event_handler_t));
-  } else if (scheme_handler == WIFI_PROV_SCHEME_HANDLER_FREE_BLE) {
-    wifi_prov_event_handler_t scheme_event_handler = WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BLE;
-    memcpy(&config.scheme_event_handler, &scheme_event_handler, sizeof(wifi_prov_event_handler_t));
+  } else if (scheme_handler == NETWORK_PROV_SCHEME_HANDLER_FREE_BTDM) {
+    network_prov_event_handler_t scheme_event_handler = NETWORK_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BTDM;
+    memcpy(&config.scheme_event_handler, &scheme_event_handler, sizeof(network_prov_event_handler_t));
+  } else if (scheme_handler == NETWORK_PROV_SCHEME_HANDLER_FREE_BT) {
+    network_prov_event_handler_t scheme_event_handler = NETWORK_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BT;
+    memcpy(&config.scheme_event_handler, &scheme_event_handler, sizeof(network_prov_event_handler_t));
+  } else if (scheme_handler == NETWORK_PROV_SCHEME_HANDLER_FREE_BLE) {
+    network_prov_event_handler_t scheme_event_handler = NETWORK_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BLE;
+    memcpy(&config.scheme_event_handler, &scheme_event_handler, sizeof(network_prov_event_handler_t));
   } else {
     log_e("Unknown scheme handler!");
     return;
@@ -110,26 +110,26 @@ void WiFiProvClass ::beginProvision(
   config.app_event_handler.event_cb = NULL;
   config.app_event_handler.user_data = NULL;
   WiFi.STA.begin(false);
-  if (wifi_prov_mgr_init(config) != ESP_OK) {
-    log_e("wifi_prov_mgr_init failed!");
+  if (network_prov_mgr_init(config) != ESP_OK) {
+    log_e("network_prov_mgr_init failed!");
     return;
   }
   if (reset_provisioned) {
     log_i("Resetting provisioned data.");
-    wifi_prov_mgr_reset_provisioning();
-  } else if (wifi_prov_mgr_is_provisioned(&provisioned) != ESP_OK) {
-    log_e("wifi_prov_mgr_is_provisioned failed!");
-    wifi_prov_mgr_deinit();
+    network_prov_mgr_reset_wifi_provisioning();
+  } else if (network_prov_mgr_is_wifi_provisioned(&provisioned) != ESP_OK) {
+    log_e("network_prov_mgr_is_wifi_provisioned failed!");
+    network_prov_mgr_deinit();
     return;
   }
   if (provisioned == false) {
 #if CONFIG_BLUEDROID_ENABLED
-    if (prov_scheme == WIFI_PROV_SCHEME_BLE) {
+    if (prov_scheme == NETWORK_PROV_SCHEME_BLE) {
       service_key = NULL;
       if (uuid == NULL) {
         uuid = (uint8_t *)custom_service_uuid;
       }
-      wifi_prov_scheme_ble_set_service_uuid(uuid);
+      network_prov_scheme_ble_set_service_uuid(uuid);
     }
 #endif
 
@@ -139,7 +139,7 @@ void WiFiProvClass ::beginProvision(
     }
 
 #if CONFIG_BLUEDROID_ENABLED
-    if (prov_scheme == WIFI_PROV_SCHEME_BLE) {
+    if (prov_scheme == NETWORK_PROV_SCHEME_BLE) {
       log_i("Starting AP using BLE. service_name : %s, pop : %s", service_name, pop);
     } else {
 #endif
@@ -151,8 +151,8 @@ void WiFiProvClass ::beginProvision(
 #if CONFIG_BLUEDROID_ENABLED
     }
 #endif
-    if (wifi_prov_mgr_start_provisioning(security, pop, service_name, service_key) != ESP_OK) {
-      log_e("wifi_prov_mgr_start_provisioning failed!");
+    if (network_prov_mgr_start_provisioning(security, pop, service_name, service_key) != ESP_OK) {
+      log_e("network_prov_mgr_start_provisioning failed!");
       return;
     }
   } else {
@@ -163,7 +163,7 @@ void WiFiProvClass ::beginProvision(
     log_i("Attempting connect to AP: %s\n", conf.sta.ssid);
 #endif
     esp_wifi_start();
-    wifi_prov_mgr_deinit();
+    network_prov_mgr_deinit();
     WiFi.begin();
   }
 }

libraries/WiFiProv/src/WiFiProv.h

@@ -23,32 +23,32 @@
 #if SOC_WIFI_SUPPORTED
 
 #include "WiFi.h"
-#include "wifi_provisioning/manager.h"
+#include "network_provisioning/manager.h"
 //Select the scheme using which you want to provision
 typedef enum {
-  WIFI_PROV_SCHEME_SOFTAP,
+  NETWORK_PROV_SCHEME_SOFTAP,
 #if CONFIG_BLUEDROID_ENABLED
-  WIFI_PROV_SCHEME_BLE,
+  NETWORK_PROV_SCHEME_BLE,
 #endif
-  WIFI_PROV_SCHEME_MAX
+  NETWORK_PROV_SCHEME_MAX
 } prov_scheme_t;
 
 typedef enum {
-  WIFI_PROV_SCHEME_HANDLER_NONE,
+  NETWORK_PROV_SCHEME_HANDLER_NONE,
 #if CONFIG_BLUEDROID_ENABLED
-  WIFI_PROV_SCHEME_HANDLER_FREE_BTDM,
-  WIFI_PROV_SCHEME_HANDLER_FREE_BLE,
-  WIFI_PROV_SCHEME_HANDLER_FREE_BT,
+  NETWORK_PROV_SCHEME_HANDLER_FREE_BTDM,
+  NETWORK_PROV_SCHEME_HANDLER_FREE_BLE,
+  NETWORK_PROV_SCHEME_HANDLER_FREE_BT,
 #endif
-  WIFI_PROV_SCHEME_HANDLER_MAX
+  NETWORK_PROV_SCHEME_HANDLER_MAX
 } scheme_handler_t;
 
 //Provisioning class
 class WiFiProvClass {
 public:
   void beginProvision(
-    prov_scheme_t prov_scheme = WIFI_PROV_SCHEME_SOFTAP, scheme_handler_t scheme_handler = WIFI_PROV_SCHEME_HANDLER_NONE,
-    wifi_prov_security_t security = WIFI_PROV_SECURITY_1, const char *pop = "abcd1234", const char *service_name = NULL, const char *service_key = NULL,
+    prov_scheme_t prov_scheme = NETWORK_PROV_SCHEME_SOFTAP, scheme_handler_t scheme_handler = NETWORK_PROV_SCHEME_HANDLER_NONE,
+    network_prov_security_t security = NETWORK_PROV_SECURITY_1, const char *pop = "abcd1234", const char *service_name = NULL, const char *service_key = NULL,
     uint8_t *uuid = NULL, bool reset_provisioned = false
   );
   void printQR(const char *name, const char *pop, const char *transport);