Allow pairing an on network device

custom_components/matter_experimental/__init__.py

@@ -125,6 +125,22 @@ async def commission(call: ServiceCall) -> None:
         vol.Schema({"code": str}),
     )
 
+    async def accept_shared_device(call: ServiceCall) -> None:
+        """Accept a shared device."""
+        matter: Matter = list(hass.data[DOMAIN].values())[0]
+        try:
+            await matter.commission_on_network(call.data["pin"])
+        except FailedCommand as err:
+            raise HomeAssistantError(str(err)) from err
+
+    async_register_admin_service(
+        hass,
+        DOMAIN,
+        "accept_shared_device",
+        accept_shared_device,
+        vol.Schema({"pin": vol.Coerce(int)}),
+    )
+
     async def set_wifi(call: ServiceCall) -> None:
         """Handle set wifi creds."""
         matter: Matter = list(hass.data[DOMAIN].values())[0]

custom_components/matter_experimental/services.yaml

@@ -8,6 +8,17 @@ commission:
       required: true
       selector:
         text:
+accept_shared_device:
+  name: Accept shared device
+  description: >
+    Add a shared device to your Matter network.
+  fields:
+    pin:
+      name: Pin code
+      required: true
+      selector:
+        text:
+
 set_wifi:
   name: Set Wi-Fi credentials
   description: >

matter_server/client/matter.py

@@ -100,6 +100,25 @@ async def commission(self, code: str):
 
         await self._interview_node(node_id)
 
+    async def commission_on_network(self, pin: int) -> bool:
+        """Commission a new device."""
+        if self._commission_lock is None:
+            self._commission_lock = asyncio.Lock()
+
+        async with self._commission_lock:
+            node_id = self.next_node_id
+            if not await self.client.driver.device_controller.commission_on_network(
+                node_id, pin
+            ):
+                return False
+            self._nodes[node_id] = None
+            self.next_node_id += 1
+            # Save right away because we don't want to lose node IDs
+            await self.adapter.save_data(self._data_to_save())
+
+        await self._interview_node(node_id)
+        return True
+
     async def delete_node(self, node_id: int) -> None:
         """Delete a node."""
         # TODO notify anyone using MatterNode

matter_server/client/model/device_controller.py

@@ -61,6 +61,15 @@ async def commission_with_code(self, setupPayload: str, nodeid: int):
             },
         )
 
+    async def commission_on_network(self, nodeId: int, setupPinCode: int):
+        return await self._async_send_command(
+            "CommissionOnNetwork",
+            {
+                "nodeId": nodeId,
+                "setupPinCode": setupPinCode,
+            },
+        )
+
     async def set_wifi_credentials(self, ssid: str, credentials: str):
         return await self._async_send_command(
             "SetWiFiCredentials",

matter_server/server/active_connection.py

@@ -114,6 +114,10 @@ async def _handle_server_GetInfo(self, msg: CommandMessage):
 
     @commands.register("device_controller.CommissionWithCode")
     async def _handle_device_controller_CommissionWithCode(self, msg: CommandMessage):
+        """Commission a device.
+
+        Return boolean if successful.
+        """
         if not self.server.stack.wifi_cred_set:
             self.logger.warning("Received commissioning without Wi-Fi set")
 
@@ -123,6 +127,20 @@ async def _handle_device_controller_CommissionWithCode(self, msg: CommandMessage
         )
         self._send_message(SuccessResultMessage(msg.messageId, {"raw": result}))
 
+    @commands.register("device_controller.CommissionOnNetwork")
+    async def _handle_device_controller_CommissionOnNetwork(self, msg: CommandMessage):
+        """Commission a device already connected to the network.
+
+        Return boolean if successful.
+        """
+        result = await self.loop.run_in_executor(
+            None,
+            partial(
+                self.server.stack.device_controller.CommissionOnNetwork, **msg.args
+            ),
+        )
+        self._send_message(SuccessResultMessage(msg.messageId, {"raw": result}))
+
     @commands.register("device_controller.Read")
     async def _handle_device_controller_Read(self, msg: CommandMessage):
         if isinstance(msg.args.get("attributes"), list):