homekit_switch: Add provisioning timeout support similar to rest of the examples

Author: shahpiyushv

examples/homekit_switch/components/app_wifi/Kconfig.projbuild

@@ -32,4 +32,37 @@ menu "App Wi-Fi Provisioning"
         help
             "Use Apple WAC Provisioning"
 
+    config APP_WIFI_RESET_PROV_ON_FAILURE
+        bool
+        default y
+        prompt "Reset provisioned credentials and state machine after session failure"
+        help
+            Enable reseting provisioned credentials and state machine after session failure.
+            This will restart the provisioning service after retries are exhausted.
+
+    config APP_WIFI_PROV_MAX_RETRY_CNT
+        int
+        default 5
+        prompt "Max retries before reseting provisioning state machine"
+        depends on APP_WIFI_RESET_PROV_ON_FAILURE
+        help
+            Set the Maximum retry to avoid reconnecting to an inexistent AP or if credentials
+            are misconfigured. Provisioned credentials are erased and internal state machine
+            is reset after this threshold is reached.
+
+    config APP_WIFI_PROV_TIMEOUT_PERIOD
+        int "Provisioning Timeout"
+        default 10
+        help
+            Timeout (in minutes) after which the provisioning will auto stop. A reboot will be required
+            to restart provisioning. Set to 0 if you do not want provisioning to auto stop.
+            It is recommended to set this to 15 or 10 depending on the HomeKit spec version supported,
+            to match the WAC timeout.
+
+    config APP_WIFI_PROV_NAME_PREFIX
+        string "Provisioning Name Prefix"
+        default "PROV"
+        help
+            Provisioning Name Prefix.
+
 endmenu

examples/homekit_switch/components/app_wifi/app_wifi_with_homekit.c

@@ -35,8 +35,10 @@
 #include <qrcode.h>
 #include <nvs.h>
 #include <nvs_flash.h>
+#include <esp_timer.h>
 #include "app_wifi_with_homekit.h"
 
+ESP_EVENT_DEFINE_BASE(APP_WIFI_EVENT);
 #ifdef CONFIG_APP_WIFI_USE_WAC_PROVISIONING
 #include <hap_wac.h>
 #endif /* CONFIG_APP_WIFI_USE_WAC_PROVISIONING */
@@ -54,21 +56,35 @@ static EventGroupHandle_t wifi_event_group;
 #define CREDENTIALS_NAMESPACE   "rmaker_creds"
 #define RANDOM_NVS_KEY          "random"
 
+#define POP_STR_SIZE    9
+static esp_timer_handle_t prov_stop_timer;
+/* Timeout period in minutes */
+#define APP_WIFI_PROV_TIMEOUT_PERIOD   CONFIG_APP_WIFI_PROV_TIMEOUT_PERIOD
+/* Autofetch period in micro-seconds */
+static uint64_t prov_timeout_period = (APP_WIFI_PROV_TIMEOUT_PERIOD * 60 * 1000000LL);
+
 static void app_wifi_print_qr(const char *name, const char *pop, const char *transport)
 {
-    if (!name || !pop || !transport) {
+    if (!name || !transport) {
         ESP_LOGW(TAG, "Cannot generate QR code payload. Data missing.");
         return;
     }
     char payload[150];
-    snprintf(payload, sizeof(payload), "{\"ver\":\"%s\",\"name\":\"%s\"" \
-                    ",\"pop\":\"%s\",\"transport\":\"%s\"}",
-                    PROV_QR_VERSION, name, pop, transport);
+    if (pop) {
+        snprintf(payload, sizeof(payload), "{\"ver\":\"%s\",\"name\":\"%s\"" \
+                ",\"pop\":\"%s\",\"transport\":\"%s\"}",
+                PROV_QR_VERSION, name, pop, transport);
+    } else {
+        snprintf(payload, sizeof(payload), "{\"ver\":\"%s\",\"name\":\"%s\"" \
+                ",\"transport\":\"%s\"}",
+                PROV_QR_VERSION, name, transport);
+    }
 #ifdef CONFIG_APP_WIFI_PROV_SHOW_QR
     ESP_LOGI(TAG, "Scan this QR code from the phone app for Provisioning.");
     qrcode_display(payload);
 #endif /* CONFIG_APP_WIFI_PROV_SHOW_QR */
     ESP_LOGI(TAG, "If QR code is not visible, copy paste the below URL in a browser.\n%s?data=%s", QRCODE_BASE_URL, payload);
+    esp_event_post(APP_WIFI_EVENT, APP_WIFI_EVENT_QR_DISPLAY, payload, strlen(payload) + 1, portMAX_DELAY);
 }
 
 #ifdef CONFIG_APP_WIFI_USE_WAC_PROVISIONING
@@ -97,6 +113,9 @@ static void app_wac_sta_connect(wifi_config_t *wifi_cfg)
 static void event_handler(void* arg, esp_event_base_t event_base,
                           int32_t event_id, void* event_data)
 {
+#ifdef CONFIG_APP_WIFI_RESET_PROV_ON_FAILURE
+    static int retries = 0;
+#endif
     if (event_base == WIFI_PROV_EVENT) {
         switch (event_id) {
             case WIFI_PROV_START:
@@ -116,12 +135,33 @@ static void event_handler(void* arg, esp_event_base_t event_base,
                          "\n\tPlease reset to factory and retry provisioning",
                          (*reason == WIFI_PROV_STA_AUTH_ERROR) ?
                          "Wi-Fi station authentication failed" : "Wi-Fi access-point not found");
+#ifdef CONFIG_APP_WIFI_RESET_PROV_ON_FAILURE
+                retries++;
+                if (retries >= CONFIG_APP_WIFI_PROV_MAX_RETRY_CNT) {
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 3, 1)
+                    ESP_LOGI(TAG, "Failed to connect with provisioned AP, reseting provisioned credentials");
+                    wifi_prov_mgr_reset_sm_state_on_failure();
+                    esp_event_post(APP_WIFI_EVENT, APP_WIFI_EVENT_PROV_RESTART, NULL, 0, portMAX_DELAY);
+#else
+                    ESP_LOGW(TAG, "Failed to connect with provisioned AP, please reset to provisioning manually");
+#endif
+                    retries = 0;
+                }
+#endif
                 break;
             }
             case WIFI_PROV_CRED_SUCCESS:
                 ESP_LOGI(TAG, "Provisioning successful");
+#ifdef CONFIG_APP_WIFI_RESET_PROV_ON_FAILURE
+                retries = 0;
+#endif
                 break;
             case WIFI_PROV_END:
+                if (prov_stop_timer) {
+                    esp_timer_stop(prov_stop_timer);
+                    esp_timer_delete(prov_stop_timer);
+                    prov_stop_timer = NULL;
+                }
 #ifdef CONFIG_APP_WIFI_USE_WAC_PROVISIONING
                 hap_wac_stop();
 #endif
@@ -209,14 +249,14 @@ static esp_err_t read_random_bytes_from_nvs(uint8_t **random_bytes, size_t *len)
 static esp_err_t get_device_service_name(char *service_name, size_t max)
 {
     uint8_t *nvs_random = NULL;
-    const char *ssid_prefix = "PROV_";
+    const char *ssid_prefix = CONFIG_APP_WIFI_PROV_NAME_PREFIX;
     size_t nvs_random_size = 0;
     if ((read_random_bytes_from_nvs(&nvs_random, &nvs_random_size) != ESP_OK) || nvs_random_size < 3) {
         uint8_t eth_mac[6];
         esp_wifi_get_mac(WIFI_IF_STA, eth_mac);
-        snprintf(service_name, max, "%s%02x%02x%02x", ssid_prefix, eth_mac[3], eth_mac[4], eth_mac[5]);
+        snprintf(service_name, max, "%s_%02x%02x%02x", ssid_prefix, eth_mac[3], eth_mac[4], eth_mac[5]);
     } else {
-        snprintf(service_name, max, "%s%02x%02x%02x", ssid_prefix, nvs_random[nvs_random_size - 3],
+        snprintf(service_name, max, "%s_%02x%02x%02x", ssid_prefix, nvs_random[nvs_random_size - 3],
                 nvs_random[nvs_random_size - 2], nvs_random[nvs_random_size - 1]);
     }
     if (nvs_random) {
@@ -226,34 +266,45 @@ static esp_err_t get_device_service_name(char *service_name, size_t max)
 }
 
 
-static esp_err_t get_device_pop(char *pop, size_t max, app_wifi_pop_type_t pop_type)
+static char *get_device_pop(app_wifi_pop_type_t pop_type)
 {
-    if (!pop || !max) {
-        return ESP_ERR_INVALID_ARG;
+    if (pop_type == POP_TYPE_NONE) {
+        return NULL;
+    }
+    char *pop = calloc(1, POP_STR_SIZE);
+    if (!pop) {
+        ESP_LOGE(TAG, "Failed to allocate memory for PoP.");
+        return NULL;
     }
 
     if (pop_type == POP_TYPE_MAC) {
         uint8_t eth_mac[6];
         esp_err_t err = esp_wifi_get_mac(WIFI_IF_STA, eth_mac);
         if (err == ESP_OK) {
-            snprintf(pop, max, "%02x%02x%02x%02x", eth_mac[2], eth_mac[3], eth_mac[4], eth_mac[5]);
-            return ESP_OK;
+            snprintf(pop, POP_STR_SIZE, "%02x%02x%02x%02x", eth_mac[2], eth_mac[3], eth_mac[4], eth_mac[5]);
+            return pop;
         } else {
-            return err;
+            ESP_LOGE(TAG, "Failed to get MAC address to generate PoP.");
+            goto pop_err;
         }
     } else if (pop_type == POP_TYPE_RANDOM) {
-        uint8_t *nvs_random;
+        uint8_t *nvs_random = NULL;
         size_t nvs_random_size = 0;
         if ((read_random_bytes_from_nvs(&nvs_random, &nvs_random_size) != ESP_OK) || nvs_random_size < 4) {
-            return ESP_ERR_NOT_FOUND;
+            ESP_LOGE(TAG, "Failed to read random bytes from NVS to generate PoP.");
+            if (nvs_random) {
+                free(nvs_random);
+            }
+            goto pop_err;
         } else {
-            snprintf(pop, max, "%02x%02x%02x%02x", nvs_random[0], nvs_random[1], nvs_random[2], nvs_random[3]);
+            snprintf(pop, POP_STR_SIZE, "%02x%02x%02x%02x", nvs_random[0], nvs_random[1], nvs_random[2], nvs_random[3]);
             free(nvs_random);
-            return ESP_OK;
+            return pop;
         }
-    } else {
-        return ESP_ERR_INVALID_ARG;
     }
+pop_err:
+    free(pop);
+    return NULL;
 }
 
 void app_wifi_with_homekit_init(void)
@@ -288,6 +339,35 @@ void app_wifi_with_homekit_init(void)
     ESP_ERROR_CHECK(esp_wifi_init(&cfg));
 }
 
+static void app_wifi_prov_stop(void *priv)
+{
+    ESP_LOGW(TAG, "Provisioning timed out. Please reboot device to restart provisioning.");
+    wifi_prov_mgr_stop_provisioning();
+    esp_event_post(APP_WIFI_EVENT, APP_WIFI_EVENT_PROV_TIMEOUT, NULL, 0, portMAX_DELAY);
+}
+
+esp_err_t app_wifi_start_timer(void)
+{
+    if (prov_timeout_period == 0) {
+        return ESP_OK;
+    }
+    esp_timer_create_args_t prov_stop_timer_conf = {
+        .callback = app_wifi_prov_stop,
+        .arg = NULL,
+        .dispatch_method = ESP_TIMER_TASK,
+        .name = "app_wifi_prov_stop_tm"
+    };
+    if (esp_timer_create(&prov_stop_timer_conf, &prov_stop_timer) == ESP_OK) {
+        esp_timer_start_once(prov_stop_timer, prov_timeout_period);
+        ESP_LOGI(TAG, "Provisioning will auto stop after %d minute(s).",
+                APP_WIFI_PROV_TIMEOUT_PERIOD);
+        return ESP_OK;
+    } else {
+        ESP_LOGE(TAG, "Failed to create Provisioning auto stop timer.");
+    }
+    return ESP_FAIL;
+}
+
 esp_err_t app_wifi_with_homekit_start(app_wifi_pop_type_t pop_type)
 {
     /* Configuration for the provisioning manager */
@@ -329,7 +409,6 @@ esp_err_t app_wifi_with_homekit_start(app_wifi_pop_type_t pop_type)
 #ifdef ESP_NETIF_SUPPORTED
         esp_netif_create_default_wifi_ap();
 #endif
-
         /* What is the Device Service Name that we want
          * This translates to :
          *     - Wi-Fi SSID when scheme is wifi_prov_scheme_softap
@@ -338,6 +417,12 @@ esp_err_t app_wifi_with_homekit_start(app_wifi_pop_type_t pop_type)
         char service_name[12];
         get_device_service_name(service_name, sizeof(service_name));
 
+        /* What is the service key (Wi-Fi password)
+         * NULL = Open network
+         * This is ignored when scheme is wifi_prov_scheme_ble
+         */
+        const char *service_key = NULL;
+
         /* What is the security level that we want (0 or 1):
          *      - WIFI_PROV_SECURITY_0 is simply plain text communication.
          *      - WIFI_PROV_SECURITY_1 is secure communication which consists of secure handshake
@@ -350,19 +435,11 @@ esp_err_t app_wifi_with_homekit_start(app_wifi_pop_type_t pop_type)
          *      - this should be a string with length > 0
          *      - NULL if not used
          */
-        char pop[9];
-        esp_err_t err = get_device_pop(pop, sizeof(pop), pop_type);
-        if (err != ESP_OK) {
-            ESP_LOGE(TAG, "Error: %d. Failed to get PoP from NVS, Please perform Claiming.", err);
-            return err;
+        char *pop = get_device_pop(pop_type);
+        if ((pop_type != POP_TYPE_NONE) && (pop == NULL)) {
+            return ESP_ERR_NO_MEM;
         }
 
-        /* What is the service key (Wi-Fi password)
-         * NULL = Open network
-         * This is ignored when scheme is wifi_prov_scheme_ble
-         */
-        const char *service_key = NULL;
-
 #ifdef CONFIG_APP_WIFI_PROV_TRANSPORT_BLE
         /* This step is only useful when scheme is wifi_prov_scheme_ble. This will
          * set a custom 128 bit UUID which will be included in the BLE advertisement
@@ -379,12 +456,14 @@ esp_err_t app_wifi_with_homekit_start(app_wifi_pop_type_t pop_type)
             0xb4, 0xdf, 0x5a, 0x1c, 0x3f, 0x6b, 0xf4, 0xbf,
             0xea, 0x4a, 0x82, 0x03, 0x04, 0x90, 0x1a, 0x02,
         };
-        err = wifi_prov_scheme_ble_set_service_uuid(custom_service_uuid);
+        esp_err_t err = wifi_prov_scheme_ble_set_service_uuid(custom_service_uuid);
         if (err != ESP_OK) {
             ESP_LOGE(TAG, "wifi_prov_scheme_ble_set_service_uuid failed %d", err);
             return err;
         }
 #endif /* CONFIG_APP_WIFI_PROV_TRANSPORT_BLE */
+
+
 #ifdef CONFIG_APP_WIFI_PROV_TRANSPORT_SOFTAP
         wifi_prov_scheme_softap_set_httpd_handle(hap_platform_httpd_get_handle());
 #endif /* CONFIG_APP_WIFI_PROV_TRANSPORT_SOFTAP */
@@ -397,9 +476,13 @@ esp_err_t app_wifi_with_homekit_start(app_wifi_pop_type_t pop_type)
 #else /* CONFIG_APP_WIFI_PROV_TRANSPORT_SOFTAP */
         app_wifi_print_qr(service_name, pop, PROV_TRANSPORT_SOFTAP);
 #endif /* CONFIG_APP_WIFI_PROV_TRANSPORT_BLE */
-        ESP_LOGI(TAG, "Provisioning Started. Name : %s, POP : %s", service_name, pop);
+        ESP_LOGI(TAG, "Provisioning Started. Name : %s, POP : %s", service_name, pop ? pop : "<null>");
+        app_wifi_start_timer();
 #ifdef CONFIG_APP_WIFI_USE_WAC_PROVISIONING
         esp_event_handler_register(HAP_WAC_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL);
+        if (pop) {
+            free(pop);
+        }
         hap_wac_start();
 #endif /* CONFIG_APP_WIFI_USE_WAC_PROVISIONING */
     } else {

examples/homekit_switch/components/app_wifi/app_wifi_with_homekit.h

@@ -7,13 +7,31 @@
 */
 #pragma once
 #include <esp_err.h>
+#include <esp_event.h>
+
+/** ESP RainMaker Event Base */
+ESP_EVENT_DECLARE_BASE(APP_WIFI_EVENT);
+
+/** App Wi-Fir Events */
+typedef enum {
+    /** QR code available for display. Associated data is the NULL terminated QR payload. */
+    APP_WIFI_EVENT_QR_DISPLAY = 1,
+    /** Provisioning timed out */
+    APP_WIFI_EVENT_PROV_TIMEOUT,
+    /** Provisioning has restarted due to failures (Invalid SSID/Passphrase) */
+    APP_WIFI_EVENT_PROV_RESTART,
+} app_wifi_event_t;
 
 /** Types of Proof of Possession */
 typedef enum {
     /** Use MAC address to generate PoP */
     POP_TYPE_MAC,
     /** Use random stream generated and stored in fctry partition during claiming process as PoP */
-    POP_TYPE_RANDOM
+    POP_TYPE_RANDOM,
+    /** Do not use any PoP.
+     * Use this option with caution. Consider using `CONFIG_APP_WIFI_PROV_TIMEOUT_PERIOD` with this.
+     */
+    POP_TYPE_NONE
 } app_wifi_pop_type_t;
 
 void app_wifi_with_homekit_init();

examples/homekit_switch/main/app_main.c

@@ -79,9 +79,33 @@ static void event_handler(void* arg, esp_event_base_t event_base,
             case RMAKER_EVENT_FACTORY_RESET:
                 ESP_LOGI(TAG, "Node reset to factory defaults.");
                 break;
+            case RMAKER_MQTT_EVENT_CONNECTED:
+                ESP_LOGI(TAG, "MQTT Connected.");
+                break;
+            case RMAKER_MQTT_EVENT_DISCONNECTED:
+                ESP_LOGI(TAG, "MQTT Disconnected.");
+                break;
+            case RMAKER_MQTT_EVENT_PUBLISHED:
+                ESP_LOGI(TAG, "MQTT Published. Msg id: %d.", *((int *)event_data));
+                break;
             default:
                 ESP_LOGW(TAG, "Unhandled RainMaker Common Event: %d", event_id);
         }
+    } else if (event_base == APP_WIFI_EVENT) {
+        switch (event_id) {
+            case APP_WIFI_EVENT_QR_DISPLAY:
+                ESP_LOGI(TAG, "Provisioning QR : %s", (char *)event_data);
+                break;
+            case APP_WIFI_EVENT_PROV_TIMEOUT:
+                ESP_LOGI(TAG, "Provisioning Timed Out. Please reboot.");
+                break;
+            case APP_WIFI_EVENT_PROV_RESTART:
+                ESP_LOGI(TAG, "Provisioning has restarted due to failures.");
+                break;
+            default:
+                ESP_LOGW(TAG, "Unhandled App Wi-Fi Event: %d", event_id);
+                break;
+        }
     } else {
         ESP_LOGW(TAG, "Invalid event received!");
     }
@@ -110,6 +134,8 @@ void app_main()
 
     /* Register an event handler to catch RainMaker events */
     ESP_ERROR_CHECK(esp_event_handler_register(RMAKER_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
+    ESP_ERROR_CHECK(esp_event_handler_register(RMAKER_COMMON_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
+    ESP_ERROR_CHECK(esp_event_handler_register(APP_WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
 
     /* Initialize the ESP RainMaker Agent.
      * Note that this should be called after app_wifi_with_homekit_init() but before app_wifi_with_homekit_start()