esp_rmaker_user_mapping: Create and register user_mapping handlers internally

Earlier, it was the application code's responsibility to call the
esp_rmaker_user_mapping_endpoint_create() and esp_rmaker_user_mapping_endpoint_register()
APIs at appropriate places in Wi-Fi provisioning code to enable user node mapping
functionality. To simplify this, the logic has been moved to RainMaker Core, so that
this happens automatically.

For some reason, if you want to retain the older logic in your application code
and do not want RainMaker_core to enable this, please set the
CONFIG_ESP_RMAKER_DISABLE_USER_MAPPING_PROV config option.

Author: shahpiyushv

components/esp_rainmaker/Kconfig.projbuild

@@ -109,6 +109,15 @@ menu "ESP RainMaker Config"
         help
             Default SNTP Server which is used for time synchronization.
 
+    config ESP_RMAKER_DISABLE_USER_MAPPING_PROV
+        bool "Disable User Mapping during Provisioning"
+        default n
+        help
+            The handlers for User Node Mapping are now registered internally by ESP RainMaker core,
+            by registering to appropriate Wi-Fi Provisioning events. If your application code also
+            has the calls to create and register the user mapping handlers, enable this config
+            option to prevent duplication.
+
     choice ESP_RMAKER_CONSOLE_UART_NUM
         prompt "UART for console input"
         default ESP_RMAKER_CONSOLE_UART_NUM_0

components/esp_rainmaker/include/esp_rmaker_user_mapping.h

@@ -29,7 +29,7 @@ extern "C"
  * @return ESP_OK on success
  * @return error on failure
  */
-esp_err_t esp_rmaker_user_mapping_endpoint_create();
+esp_err_t esp_rmaker_user_mapping_endpoint_create(void);
 
 /**
  * Register User Mapping Endpoint
@@ -41,7 +41,7 @@ esp_err_t esp_rmaker_user_mapping_endpoint_create();
  * @return ESP_OK on success
  * @return error on failure
  */
-esp_err_t esp_rmaker_user_mapping_endpoint_register();
+esp_err_t esp_rmaker_user_mapping_endpoint_register(void);
 
 /** Add User-Node mapping
  *

components/esp_rainmaker/src/core/esp_rmaker_core.c

@@ -144,6 +144,9 @@ static esp_err_t esp_rmaker_deinit_priv_data(esp_rmaker_priv_data_t *rmaker_priv
     if (rmaker_priv_data->work_queue) {
         vQueueDelete(rmaker_priv_data->work_queue);
     }
+#ifndef CONFIG_ESP_RMAKER_DISABLE_USER_MAPPING_PROV
+    esp_rmaker_user_mapping_prov_deinit();
+#endif
 #ifdef ESP_RMAKER_CLAIM_ENABLED
     if (rmaker_priv_data->claim_data) {
         esp_rmaker_claim_data_free(rmaker_priv_data->claim_data);
@@ -221,6 +224,14 @@ static esp_err_t esp_rmaker_init(const esp_rmaker_config_t *config)
         ESP_LOGE(TAG, "ESP RainMaker Queue Creation Failed");
         return ESP_ERR_NO_MEM;
     }
+#ifndef CONFIG_ESP_RMAKER_DISABLE_USER_MAPPING_PROV
+    if (esp_rmaker_user_mapping_prov_init()) {
+        esp_rmaker_deinit_priv_data(esp_rmaker_priv_data);
+        esp_rmaker_priv_data = NULL;
+        ESP_LOGE(TAG, "Could not initialise User-Node mapping.");
+        return ESP_FAIL;
+    }
+#endif /* !CONFIG_ESP_RMAKER_DISABLE_USER_MAPPING_PROV */
     esp_rmaker_priv_data->mqtt_config = esp_rmaker_get_mqtt_config();
     if (!esp_rmaker_priv_data->mqtt_config) {
 #ifdef ESP_RMAKER_CLAIM_ENABLED

components/esp_rainmaker/src/core/esp_rmaker_internal.h

@@ -97,7 +97,8 @@ esp_err_t esp_rmaker_attribute_delete(esp_rmaker_attr_t *attr);
 char *esp_rmaker_get_node_config(void);
 char *esp_rmaker_get_node_params(void);
 esp_err_t esp_rmaker_handle_set_params(char *data, size_t data_len, esp_rmaker_req_src_t src);
-
+esp_err_t esp_rmaker_user_mapping_prov_init(void);
+esp_err_t esp_rmaker_user_mapping_prov_deinit(void);
 static inline esp_err_t esp_rmaker_post_event(esp_rmaker_event_t event_id, void* data, size_t data_size)
 {
     return esp_event_post(RMAKER_EVENT, event_id, data, data_size, portMAX_DELAY);

components/esp_rainmaker/src/core/esp_rmaker_user_mapping.c

@@ -14,12 +14,14 @@
 
 #include <string.h>
 #include <esp_log.h>
+#include <esp_event.h>
 #include <wifi_provisioning/manager.h>
 #include <json_generator.h>
 #include <esp_rmaker_core.h>
+#include <esp_rmaker_user_mapping.h>
 #include <esp_rmaker_mqtt.h>
-
 #include "esp_rmaker_user_mapping.pb-c.h"
+#include "esp_rmaker_internal.h"
 
 static const char *TAG = "esp_rmaker_user_mapping";
 
@@ -44,6 +46,28 @@ static void esp_rmaker_user_mapping_cleanup_data(esp_rmaker_user_mapping_data_t
     }
 }
 
+static void esp_rmaker_user_mapping_event_handler(void* arg, esp_event_base_t event_base,
+                          int event_id, void* event_data)
+{
+    if (event_base == WIFI_PROV_EVENT) {
+        switch (event_id) {
+            case WIFI_PROV_INIT: {
+                if (esp_rmaker_user_mapping_endpoint_create() != ESP_OK) {
+                    ESP_LOGE(TAG, "Failed to create user mapping end point.");
+                }
+                break;
+            }
+            case WIFI_PROV_START:
+                if (esp_rmaker_user_mapping_endpoint_register() != ESP_OK) {
+                    ESP_LOGE(TAG, "Failed to register user mapping end point.");
+                }
+                break;
+            default:
+                break;
+        }
+    }
+}
+
 static void esp_rmaker_user_mapping_cb(void *priv_data)
 {
     esp_rmaker_user_mapping_data_t *data = (esp_rmaker_user_mapping_data_t *)priv_data;
@@ -86,6 +110,7 @@ esp_err_t esp_rmaker_start_user_node_mapping(char *user_id, char *secret_key)
     if (esp_rmaker_queue_work(esp_rmaker_user_mapping_cb, data) != ESP_OK) {
         goto user_mapping_error;
     }
+    esp_rmaker_user_mapping_prov_deinit();
     return ESP_OK;
 
 user_mapping_error:
@@ -141,13 +166,31 @@ int esp_rmaker_user_mapping_handler(uint32_t session_id, const uint8_t *inbuf, s
     rainmaker__rmaker_config_payload__free_unpacked(data, NULL);
     return ESP_OK;
 }
-esp_err_t esp_rmaker_user_mapping_endpoint_create()
+esp_err_t esp_rmaker_user_mapping_endpoint_create(void)
 {
     esp_err_t err = wifi_prov_mgr_endpoint_create(USER_MAPPING_ENDPOINT);
     return err;
 }
 
-esp_err_t esp_rmaker_user_mapping_endpoint_register()
+esp_err_t esp_rmaker_user_mapping_endpoint_register(void)
 {
     return wifi_prov_mgr_endpoint_register(USER_MAPPING_ENDPOINT, esp_rmaker_user_mapping_handler, NULL);
 }
+
+esp_err_t esp_rmaker_user_mapping_prov_init(void)
+{
+    int ret = ESP_OK;
+    ret = esp_event_handler_register(WIFI_PROV_EVENT, WIFI_PROV_INIT, &esp_rmaker_user_mapping_event_handler, NULL);
+    if (ret != ESP_OK) {
+        return ret;
+    }
+    ret = esp_event_handler_register(WIFI_PROV_EVENT, WIFI_PROV_START, &esp_rmaker_user_mapping_event_handler, NULL);
+    return ret;
+}
+
+esp_err_t esp_rmaker_user_mapping_prov_deinit(void)
+{
+    esp_event_handler_unregister(WIFI_PROV_EVENT, WIFI_PROV_INIT, &esp_rmaker_user_mapping_event_handler);
+    esp_event_handler_unregister(WIFI_PROV_EVENT, WIFI_PROV_START, &esp_rmaker_user_mapping_event_handler);
+    return ESP_OK;
+}

examples/common/app_wifi/app_wifi.c

@@ -31,7 +31,6 @@
 #include <wifi_provisioning/scheme_softap.h>
 #endif /* CONFIG_APP_WIFI_PROV_TRANSPORT_BLE */
 
-#include <esp_rmaker_user_mapping.h>
 #include <qrcode.h>
 #include <nvs.h>
 #include <nvs_flash.h>
@@ -314,20 +313,8 @@ esp_err_t app_wifi_start(app_wifi_pop_type_t pop_type)
         }
 #endif /* CONFIG_APP_WIFI_PROV_TRANSPORT_BLE */
 
-        /* Create endpoint for ESP Cloud User-Device Association */
-        err = esp_rmaker_user_mapping_endpoint_create();
-        if (err != ESP_OK) {
-            ESP_LOGE(TAG, "esp_rmaker_user_mapping_endpoint_create failed %d", err);
-            return err;
-        }
         /* Start provisioning service */
         ESP_ERROR_CHECK(wifi_prov_mgr_start_provisioning(security, pop, service_name, service_key));
-        /* Register endpoint for ESP Cloud User-Device Association */
-        err = esp_rmaker_user_mapping_endpoint_register();
-        if (err != ESP_OK) {
-            ESP_LOGE(TAG, "esp_rmaker_user_mapping_endpoint_register failed %d", err);
-            return err;
-        }
         /* Print QR code for provisioning */
 #ifdef CONFIG_APP_WIFI_PROV_TRANSPORT_BLE
         app_wifi_print_qr(service_name, pop, PROV_TRANSPORT_BLE);

examples/homekit_switch/main/app_wifi_with_homekit.c

@@ -32,7 +32,6 @@
 #include <hap_platform_httpd.h>
 #endif /* CONFIG_APP_WIFI_PROV_TRANSPORT_BLE */
 
-#include <esp_rmaker_user_mapping.h>
 #include <qrcode.h>
 #include <nvs.h>
 #include <nvs_flash.h>
@@ -318,20 +317,8 @@ esp_err_t app_wifi_with_homekit_start(app_wifi_pop_type_t pop_type)
         wifi_prov_scheme_softap_set_httpd_handle(hap_platform_httpd_get_handle());
 #endif /* CONFIG_APP_WIFI_PROV_TRANSPORT_SOFTAP */
 
-        /* Create endpoint for ESP Cloud User-Device Association */
-        err = esp_rmaker_user_mapping_endpoint_create();
-        if (err != ESP_OK) {
-            ESP_LOGE(TAG, "esp_rmaker_user_mapping_endpoint_create failed %d", err);
-            return err;
-        }
         /* Start provisioning service */
         ESP_ERROR_CHECK(wifi_prov_mgr_start_provisioning(security, pop, service_name, service_key));
-        /* Register endpoint for ESP Cloud User-Device Association */
-        err = esp_rmaker_user_mapping_endpoint_register();
-        if (err != ESP_OK) {
-            ESP_LOGE(TAG, "esp_rmaker_user_mapping_endpoint_register failed %d", err);
-            return err;
-        }
         /* Print QR code for provisioning */
 #ifdef CONFIG_APP_WIFI_PROV_TRANSPORT_BLE
         app_wifi_print_qr(service_name, pop, PROV_TRANSPORT_BLE);