Add support of unified provisioning to Arduino

1. WiFiProv.ino sketch is added that allows arduino users to do provisioning via SoftAP or BLE. WiFi.beginProvision( ) API is designed for provisioning in Arduino.
2. In WiFiProv.h provisioning class is defined.
3. WiFiProv.cpp contains implementation for provisioning class.
4. README.md file is added which contains detail information for working.

Author: sweetymhaiske

Diff for: CMakeLists.txt

@@ -71,6 +71,7 @@ set(LIBRARY_SRCS
   libraries/WiFi/src/WiFi.cpp
   libraries/WiFi/src/WiFiGeneric.cpp
   libraries/WiFi/src/WiFiMulti.cpp
+  libraries/WiFi/src/WiFiProv.cpp
   libraries/WiFi/src/WiFiScan.cpp
   libraries/WiFi/src/WiFiServer.cpp
   libraries/WiFi/src/WiFiSTA.cpp

Diff for: libraries/WiFi/examples/WiFiProv/README.md

@@ -0,0 +1,135 @@
+# Provisioning for Arduino
+
+This sketch implements provisioning using various IDF components
+
+# Description
+
+This example allows Arduino user to choose either BLE or SOFTAP as a mode of transport, over which the provisioning related communication is to take place, between the device (to be provisioned) and the client (owner of the device).
+
+## API's introduced for provisioning
+
+## WiFi.onEvent()
+
+Using this API user can register to recieve WIFI Events and Provisioning Events
+
+#### Parameters passed
+
+A function with following signature
+* void SysProvEvent(system_event_t * , wifi_prov_event_t * );
+ 
+#### structure [ wifi_prov_event_t ]
+
+* wifi_prov_cb_event_t event;
+* void * event_data;
+
+### WiFi.beginProvision()
+
+WiFi.beginProvision(scheme prov_scheme, wifi_prov_scheme_event_handler_t scheme_event_handler, wifi_prov_security_t security, char * pop, char * service_name, char * service_key, uint8_t * uuid);
+
+#### Parameters
+
+* prov_scheme : choose the mode of transfer
+    * WIFI_PROV_SCHEME_BLE - Using BLE
+    * WIFI_PROV_SCHEME_SOFTAP - Using SoftAP
+        
+* security : choose security type
+    * WIFI_PROV_SECURITY_1 - It allows secure communication which consists of secure handshake using key exchange and proof of possession (pop) and encryption/decryption of messages.
+
+    * WIFI_PROV_SECURITY_0 - It do not provide application level security, it involve simply plain text communication.
+
+* scheme_event_handler : specify the handlers according to the mode chosen
+    * BLE :
+        - WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BTDM - This scheme event handler is used when application doesn't need BT and BLE after provisioning is finised
+        - WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BLE - This scheme event handler is used when application doesn't need BLE to be active after provisioning is finised
+        - WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BT - This scheme event handler is used when application doesn't need BT to be active after provisioning is finised
+
+    * SoftAp :
+        - WIFI_PROV_EVENT_HANDLER_NONE
+
+* pop : It is the string that is used to provide the authentication while provisioning
+
+* service_name : Specify service name for the device while provisioning, if it is not specified then default chosen name via SoftAP is WIFI_XXX and for BLE service it is BLE_XXX where XXX is the last 3 bytes of the MAC address. 
+
+* service_key : Specify service key while provisioning, if chosen mode of provisioning is BLE then service_key is always NULL
+
+* uuid : user can specify there own 128 bit UUID while provisioning using BLE, if not specified then default value taken is
+        - {  0xb4, 0xdf, 0x5a, 0x1c, 0x3f, 0x6b, 0xf4, 0xbf,
+             0xea, 0x4a, 0x82, 0x03, 0x04, 0x90, 0x1a, 0x02, }
+
+# NOTE
+
+* If none of the parameters are specified in beginProvision then default provisioning takes place using SoftAP with
+    * scheme = WIFI_PROV_SCHEME_SOFTAP
+    * scheme_event_handler = WIFI_PROV_EVENT_HANDLER_NONE
+    * security = WIFI_PROV_SECURITY_1
+    * pop = "abcd1234"
+    * service_name = "WiFi_XXX" 
+    * service_key = NULL
+    * uuid = NULL
+
+# Log Output
+* Enable debuger : [ Tools -> Core Debug Level -> Info ] 
+
+# App required for provisioning
+
+##Gihub link
+
+* Android : (https://github.com/espressif/esp-idf-provisioning-android)
+* iOS : (https://github.com/espressif/esp-idf-provisioning-ios)
+
+## These apps are available on playstore
+
+* For SoftAP : ESP SoftAP Prov
+* For BLE : ESP BLE Prov
+
+# Example output
+
+## Provisioning using SoftAP
+
+```
+[I][WiFiProv.cpp:117] beginProvision(): Starting AP using SOFTAP
+ service_name : WIFI_XXX
+ password : 123456789
+ pop : abcd1234
+
+Provisioning started
+Give Credentials of your access point using " Android app "
+
+Received Wi-Fi credentials
+	SSID : GIONEE M2
+	Password : 123456789
+
+Connected IP address : 192.168.43.120
+Provisioning Successful
+Provisioning Ends
+
+```
+
+## Provisioning using BLE
+
+```
+[I][WiFiProv.cpp:115] beginProvision(): Starting AP using BLE
+ service_name : BLE_XXX
+ pop : abcd1234
+
+Provisioning started
+Give Credentials of your access point using " Android app "
+
+Received Wi-Fi credentials
+	SSID : GIONEE M2
+	Password : 123456789
+
+Connected IP address : 192.168.43.120
+Provisioning Successful
+Provisioning Ends
+
+```
+
+## Credentials are available on device
+
+```
+[I][WiFiProv.cpp:125] beginProvision(): Aleardy Provisioned, starting Wi-Fi STA
+[I][WiFiProv.cpp:126] beginProvision(): CONNECTING ACCESS POINT CREDENTIALS : 
+[I][WiFiProv.cpp:126] beginProvision(): SSID : GIONEE M2
+
+```

Diff for: libraries/WiFi/examples/WiFiProv/WiFiProv.ino

@@ -0,0 +1,63 @@
+#include "WiFi.h"
+void SysProvEvent(system_event_t *sys_event,wifi_prov_event_t *prov_event)
+{
+    if(sys_event) {
+      switch (sys_event->event_id) {
+      case SYSTEM_EVENT_STA_GOT_IP:
+          Serial.print("\nConnected IP address : ");
+          Serial.println(ip4addr_ntoa(&sys_event->event_info.got_ip.ip_info.ip));
+          break;
+      case SYSTEM_EVENT_STA_DISCONNECTED:
+          Serial.println("\nDisconnected. Connecting to the AP again... ");
+          break;
+      default:
+          break;
+      }      
+    }
+
+    if(prov_event) {
+        switch (prov_event->event) {
+        case WIFI_PROV_START:
+            Serial.println("\nProvisioning started\nGive Credentials of your access point using \" Android app \"");
+            break;
+        case WIFI_PROV_CRED_RECV: { 
+            Serial.println("\nReceived Wi-Fi credentials");
+            wifi_sta_config_t *wifi_sta_cfg = (wifi_sta_config_t *)prov_event->event_data;
+            Serial.print("\tSSID : ");
+            Serial.println((const char *) wifi_sta_cfg->ssid);
+            Serial.print("\tPassword : ");
+            Serial.println((char const *) wifi_sta_cfg->password);
+            break;
+        }
+        case WIFI_PROV_CRED_FAIL: { 
+            wifi_prov_sta_fail_reason_t *reason = (wifi_prov_sta_fail_reason_t *)prov_event->event_data;
+            Serial.println("\nProvisioning failed!\nPlease reset to factory and retry provisioning\n");
+            if(*reason == WIFI_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()");        
+            break;
+        }
+        case WIFI_PROV_CRED_SUCCESS:
+            Serial.println("\nProvisioning Successful");
+            break;
+        case WIFI_PROV_END:
+            Serial.println("\nProvisioning Ends");
+            break;
+        default:
+            break;
+        }      
+    }
+}
+
+void setup() {
+  Serial.begin(115200);
+  //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 };*/
+  WiFi.onEvent(SysProvEvent);
+  WiFi.beginProvision(WIFI_PROV_SCHEME_BLE, WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BTDM, WIFI_PROV_SECURITY_1, "abcd1234", "BLE_XXX", NULL, NULL);
+}
+
+void loop() {
+}

Diff for: libraries/WiFi/src/WiFi.h

@@ -37,8 +37,9 @@
 #include "WiFiClient.h"
 #include "WiFiServer.h"
 #include "WiFiUdp.h"
+#include "WiFiProv.h"
 
-class WiFiClass : public WiFiGenericClass, public WiFiSTAClass, public WiFiScanClass, public WiFiAPClass
+class WiFiClass : public WiFiGenericClass, public WiFiSTAClass, public WiFiScanClass, public WiFiAPClass, public WiFiProvClass
 {
 public:
     using WiFiGenericClass::channel;
@@ -54,8 +55,7 @@ class WiFiClass : public WiFiGenericClass, public WiFiSTAClass, public WiFiScanC
     using WiFiScanClass::BSSID;
     using WiFiScanClass::BSSIDstr;
     using WiFiScanClass::channel;
-
-public:
+public:  
     void printDiag(Print& dest);
     friend class WiFiClient;
     friend class WiFiServer;

Diff for: libraries/WiFi/src/WiFiGeneric.cpp

@@ -42,7 +42,6 @@ extern "C" {
 #include "lwip/dns.h"
 #include "esp_ipc.h"
 
-
 } //extern "C"
 
 #include "esp32-hal-log.h"
@@ -53,20 +52,42 @@ static xQueueHandle _network_event_queue;
 static TaskHandle_t _network_event_task_handle = NULL;
 static EventGroupHandle_t _network_event_group = NULL;
 
+esp_err_t postToSysQueue(system_prov_event_t *data)
+{
+    if (xQueueSend(_network_event_queue, &data, portMAX_DELAY) != pdPASS) {
+        log_w("Network Event Queue Send Failed!");
+            return ESP_FAIL;
+    }
+    return ESP_OK;
+}
+
 static void _network_event_task(void * arg){
-    system_event_t event;
+    system_prov_event_t *data;
     for (;;) {
-        if(xQueueReceive(_network_event_queue, &event, portMAX_DELAY) == pdTRUE){
-            WiFiGenericClass::_eventCallback(arg, &event);
-        }
+        if(xQueueReceive(_network_event_queue, &data, portMAX_DELAY) == pdTRUE){
+            if(data->prov_event != NULL){
+                WiFiGenericClass::_eventCallback(arg, data->sys_event, data->prov_event);
+                free(data->sys_event);
+                free(data->prov_event);
+            } else {
+                WiFiGenericClass::_eventCallback(arg, data->sys_event, NULL);
+            }
+            free(data);
+        }        
     }
     vTaskDelete(NULL);
     _network_event_task_handle = NULL;
 }
 
-static esp_err_t _network_event_cb(void *arg, system_event_t *event){
-    if (xQueueSend(_network_event_queue, event, portMAX_DELAY) != pdPASS) {
-        log_w("Network Event Queue Send Failed!");
+static esp_err_t _network_event_cb(void *arg, system_event_t *event){ 
+    system_prov_event_t *sys_prov_data = (system_prov_event_t *)malloc(sizeof(system_prov_event_t));
+    if(sys_prov_data == NULL) {
+        return ESP_FAIL;
+    }
+    sys_prov_data->sys_event = event;
+    sys_prov_data->prov_event = NULL;
+    if (postToSysQueue(sys_prov_data) != ESP_OK){
+        free(sys_prov_data);
         return ESP_FAIL;
     }
     return ESP_OK;
@@ -82,7 +103,7 @@ static bool _start_network_event_task(){
         xEventGroupSetBits(_network_event_group, WIFI_DNS_IDLE_BIT);
     }
     if(!_network_event_queue){
-        _network_event_queue = xQueueCreate(32, sizeof(system_event_t));
+        _network_event_queue = xQueueCreate(32, sizeof(system_prov_event_t));
         if(!_network_event_queue){
             log_e("Network Event Queue Create Failed!");
             return false;
@@ -144,7 +165,7 @@ static bool espWiFiStart(){
     _esp_wifi_started = true;
     system_event_t event;
     event.event_id = SYSTEM_EVENT_WIFI_READY;
-    WiFiGenericClass::_eventCallback(nullptr, &event);
+    WiFiGenericClass::_eventCallback(nullptr, &event, NULL);
     return true;
 }
 
@@ -173,9 +194,10 @@ typedef struct WiFiEventCbList {
     WiFiEventCb cb;
     WiFiEventFuncCb fcb;
     WiFiEventSysCb scb;
+    WiFiProvEventCb provcb;
     system_event_id_t event;
 
-    WiFiEventCbList() : id(current_id++), cb(NULL), fcb(NULL), scb(NULL), event(SYSTEM_EVENT_WIFI_READY) {}
+    WiFiEventCbList() : id(current_id++), cb(NULL), fcb(NULL), scb(NULL), provcb(NULL), event(SYSTEM_EVENT_WIFI_READY) {}
 } WiFiEventCbList_t;
 wifi_event_id_t WiFiEventCbList::current_id = 1;
 
@@ -230,6 +252,20 @@ int WiFiGenericClass::waitStatusBits(int bits, uint32_t timeout_ms){
  * @param cbEvent WiFiEventCb
  * @param event optional filter (WIFI_EVENT_MAX is all events)
  */
+wifi_event_id_t WiFiGenericClass::onEvent(WiFiProvEventCb cbEvent, system_event_id_t event)
+{
+    if(!cbEvent){
+        return 0;
+    }
+    WiFiEventCbList_t newEventHandler;
+    newEventHandler.cb = NULL;
+    newEventHandler.fcb = NULL;
+    newEventHandler.scb = NULL;
+    newEventHandler.provcb = cbEvent;
+    newEventHandler.event = event;
+    cbEventList.push_back(newEventHandler);
+    return newEventHandler.id;
+}
 wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventCb cbEvent, system_event_id_t event)
 {
     if(!cbEvent) {
@@ -239,6 +275,7 @@ wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventCb cbEvent, system_event_id_t
     newEventHandler.cb = cbEvent;
     newEventHandler.fcb = NULL;
     newEventHandler.scb = NULL;
+    newEventHandler.provcb = NULL;
     newEventHandler.event = event;
     cbEventList.push_back(newEventHandler);
     return newEventHandler.id;
@@ -253,6 +290,7 @@ wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventFuncCb cbEvent, system_event_
     newEventHandler.cb = NULL;
     newEventHandler.fcb = cbEvent;
     newEventHandler.scb = NULL;
+    newEventHandler.provcb = NULL;
     newEventHandler.event = event;
     cbEventList.push_back(newEventHandler);
     return newEventHandler.id;
@@ -267,6 +305,7 @@ wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventSysCb cbEvent, system_event_i
     newEventHandler.cb = NULL;
     newEventHandler.fcb = NULL;
     newEventHandler.scb = cbEvent;
+    newEventHandler.provcb = NULL;
     newEventHandler.event = event;
     cbEventList.push_back(newEventHandler);
     return newEventHandler.id;
@@ -326,8 +365,11 @@ const char * system_event_names[] = { "WIFI_READY", "SCAN_DONE", "STA_START", "S
 const char * system_event_reasons[] = { "UNSPECIFIED", "AUTH_EXPIRE", "AUTH_LEAVE", "ASSOC_EXPIRE", "ASSOC_TOOMANY", "NOT_AUTHED", "NOT_ASSOCED", "ASSOC_LEAVE", "ASSOC_NOT_AUTHED", "DISASSOC_PWRCAP_BAD", "DISASSOC_SUPCHAN_BAD", "UNSPECIFIED", "IE_INVALID", "MIC_FAILURE", "4WAY_HANDSHAKE_TIMEOUT", "GROUP_KEY_UPDATE_TIMEOUT", "IE_IN_4WAY_DIFFERS", "GROUP_CIPHER_INVALID", "PAIRWISE_CIPHER_INVALID", "AKMP_INVALID", "UNSUPP_RSN_IE_VERSION", "INVALID_RSN_IE_CAP", "802_1X_AUTH_FAILED", "CIPHER_SUITE_REJECTED", "BEACON_TIMEOUT", "NO_AP_FOUND", "AUTH_FAIL", "ASSOC_FAIL", "HANDSHAKE_TIMEOUT", "CONNECTION_FAIL" };
 #define reason2str(r) ((r>176)?system_event_reasons[r-176]:system_event_reasons[r-1])
 #endif
-esp_err_t WiFiGenericClass::_eventCallback(void *arg, system_event_t *event)
+esp_err_t WiFiGenericClass::_eventCallback(void *arg, system_event_t *event, wifi_prov_event_t *prov_event)
 {
+    if(WiFi.isProvEnabled()) {
+        wifi_prov_mgr_event_handler(arg,event);        
+    }
     if(event->event_id < 26) {
         log_d("Event: %d - %s", event->event_id, system_event_names[event->event_id]);
     }
@@ -422,7 +464,7 @@ esp_err_t WiFiGenericClass::_eventCallback(void *arg, system_event_t *event)
             setStatusBits(ETH_CONNECTED_BIT | ETH_HAS_IP6_BIT);
         }
     }
-
+ 
     for(uint32_t i = 0; i < cbEventList.size(); i++) {
         WiFiEventCbList_t entry = cbEventList[i];
         if(entry.cb || entry.fcb || entry.scb) {
@@ -436,6 +478,10 @@ esp_err_t WiFiGenericClass::_eventCallback(void *arg, system_event_t *event)
                 }
             }
         }
+
+        if(entry.provcb) {
+            entry.provcb(event,prov_event);
+        }
     }
     return ESP_OK;
 }