Merge branch 'controller/unpair_command' into 'main'

controller: Add unpairing command with callback

Closes CON-1533

See merge request app-frameworks/esp-matter!1033

Author: chshu

components/esp_matter_controller/commands/esp_matter_controller_pairing_command.cpp

@@ -191,5 +191,20 @@ esp_err_t pairing_code_wifi_thread(NodeId nodeId, const char *ssid, const char *
     return ESP_OK;
 }
 
+static void remove_fabric_handler(NodeId remote_node, CHIP_ERROR status)
+{
+    if (status == CHIP_NO_ERROR) {
+        ESP_LOGI(TAG, "Succeeded to remove fabric for remote node 0x%" PRIx64, remote_node);
+    } else {
+        ESP_LOGE(TAG, "Failed to remove fabric for remote node 0x%" PRIx64, remote_node);
+    }
+}
+
+esp_err_t unpair_device(NodeId node_id)
+{
+    auto &controller_instance = esp_matter::controller::matter_controller_client::get_instance();
+    return controller_instance.unpair(node_id, remove_fabric_handler);
+}
+
 } // namespace controller
 } // namespace esp_matter

components/esp_matter_controller/commands/esp_matter_controller_pairing_command.h

@@ -169,5 +169,15 @@ esp_err_t pairing_code_wifi(NodeId node_id, const char *ssid, const char *passwo
 esp_err_t pairing_code_wifi_thread(NodeId node_id, const char *ssid, const char *password, const char *payload,
                                    uint8_t *dataset_buf, uint8_t dataset_len);
 
+/**
+ * Unpair a Matter end-device which will remove the fabric from the remote device
+ *
+ * @param[in] node_id  NodeId of the Matter end-device to be unpaired.
+ *
+ * @return ESP_OK on success
+ * @return error in case of failure
+ */
+esp_err_t unpair_device(NodeId node_id);
+
 } // namespace controller
 } // namespace esp_matter

components/esp_matter_controller/core/esp_matter_controller_client.h

@@ -21,6 +21,7 @@
 #include <controller/AutoCommissioner.h>
 #include <controller/CHIPDeviceController.h>
 #include <controller/CommissionerDiscoveryController.h>
+#include <controller/CurrentFabricRemover.h>
 #include <controller/ExampleOperationalCredentialsIssuer.h>
 #include <controller/OperationalCredentialsDelegate.h>
 #include <credentials/DeviceAttestationCredsProvider.h>
@@ -46,6 +47,44 @@ namespace esp_matter {
 namespace controller {
 
 #ifndef CONFIG_ESP_MATTER_ENABLE_MATTER_SERVER
+typedef void (*remove_fabric_callback)(chip::NodeId remoteNodeId, CHIP_ERROR status);
+
+class auto_fabric_remover : private chip::Controller::CurrentFabricRemover
+{
+public:
+    static esp_err_t remove_fabric(chip::Controller::DeviceController *controller, chip::NodeId remote_node,
+                                   remove_fabric_callback callback)
+    {
+        auto * remover = chip::Platform::New<auto_fabric_remover>(controller, callback);
+        if (remover == nullptr) {
+            return ESP_ERR_NO_MEM;
+        }
+        CHIP_ERROR err = remover->CurrentFabricRemover::RemoveCurrentFabric(remote_node, &remover->m_matter_callback);
+        if (err != CHIP_NO_ERROR)
+        {
+            // If failing to call RemoveCurrentFabric(), delete the remover here. Otherwise the remover will be deleted
+            // in on_remove_current_fabric().
+            chip::Platform::Delete(remover);
+        }
+        return err == CHIP_NO_ERROR ? ESP_OK : ESP_FAIL;
+    }
+
+    auto_fabric_remover(chip::Controller::DeviceController *controller, remove_fabric_callback callback) :
+        chip::Controller::CurrentFabricRemover(controller), m_matter_callback(on_remove_current_fabric, this),
+        m_remove_fabric_callback(callback) {}
+private:
+    static void on_remove_current_fabric(void * context, chip::NodeId remote_node, CHIP_ERROR status)
+    {
+        auto *self = static_cast<auto_fabric_remover *>(context);
+        if (self && self->m_remove_fabric_callback) {
+            self->m_remove_fabric_callback(remote_node, status);
+        }
+        chip::Platform::Delete(self);
+    }
+    chip::Callback::Callback<chip::Controller::OnCurrentFabricRemove> m_matter_callback;
+    remove_fabric_callback m_remove_fabric_callback;
+};
+
 class matter_controller_client {
 public:
     class controller_storage_delegate : public chip::PersistentStorageDelegate {
@@ -94,6 +133,10 @@ class matter_controller_client {
 #ifdef CONFIG_ESP_MATTER_COMMISSIONER_ENABLE
     esp_err_t setup_commissioner();
     MatterDeviceCommissioner *get_commissioner() { return &m_device_commissioner; }
+    esp_err_t unpair(NodeId remote_node, remove_fabric_callback callback = nullptr)
+    {
+        return auto_fabric_remover::remove_fabric(&m_device_commissioner, remote_node, callback);
+    }
 #if CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY
     CommissionerDiscoveryController *get_discovery_controller() { return &m_commissioner_discovery_controller; }
 #endif

components/esp_matter_controller/core/esp_matter_controller_console.cpp

@@ -174,7 +174,7 @@ static bool convert_hex_str_to_bytes(const char *hex_str, uint8_t *bytes, uint8_
 #if CONFIG_ESP_MATTER_COMMISSIONER_ENABLE
 static esp_err_t controller_pairing_handler(int argc, char **argv)
 {
-    VerifyOrReturnError(argc >= 3 && argc <= 6, ESP_ERR_INVALID_ARG);
+    VerifyOrReturnError(argc >= 2 && argc <= 6, ESP_ERR_INVALID_ARG);
     esp_err_t result = ESP_ERR_INVALID_ARG;
 
     if (strncmp(argv[0], "onnetwork", sizeof("onnetwork")) == 0) {
@@ -260,6 +260,10 @@ static esp_err_t controller_pairing_handler(int argc, char **argv)
 
         result = controller::pairing_code_wifi_thread(nodeId, ssid, password, payload, dataset_tlvs_buf,
                                                       dataset_tlvs_len);
+    } else if (strncmp(argv[0], "unpair", sizeof("unpair")) == 0) {
+        VerifyOrReturnError(argc == 2, ESP_ERR_INVALID_ARG);
+        uint64_t node_id = string_to_uint64(argv[1]);
+        result = controller::unpair_device(node_id);
     }
 
     if (result != ESP_OK) {
@@ -585,15 +589,16 @@ esp_err_t controller_register_commands()
 #if CONFIG_ESP_MATTER_COMMISSIONER_ENABLE
         {
             .name = "pairing",
-            .description = "Pairing a node.\n"
+            .description = "Commands for commissioning/unpair nodes.\n"
                            "\tUsage: controller pairing onnetwork <nodeid> <pincode> OR\n"
                            "\tcontroller pairing ble-wifi <nodeid> <ssid> <password> <pincode> <discriminator> OR\n"
                            "\tcontroller pairing ble-thread <nodeid> <dataset> <pincode> <discriminator> OR\n"
                            "\tcontroller pairing ble-thread <nodeid> <dataset> <pincode> <discriminator> OR\n"
                            "\tcontroller pairing code <nodeid> <payload> OR\n"
                            "\tcontroller pairing code-wifi <nodeid> <ssid> <password> <payload> OR\n"
                            "\tcontroller pairing code-thread <nodeid> <dataset> <payload> OR\n"
-                           "\tcontroller pairing code-wifi-thread <nodeid> <ssid> <password> <dataset> <payload>",
+                           "\tcontroller pairing code-wifi-thread <nodeid> <ssid> <password> <dataset> <payload> OR\n"
+                           "\tcontroller pairing unpair <nodeid>",
             .handler = controller_pairing_handler,
         },
         {