Merge branch 'task/simplify_user_assoc' into 'master'

esp_rmaker_user_mapping: Create and register user_mapping handlers internally

See merge request app-frameworks/esp-rainmaker!174

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);