Scanner, Discovery and Controller enhancements

CHANGELOG.md

@@ -26,13 +26,17 @@ The main work (all changes without a GitHub username in brackets in the below li
   * Feature: Added generation method for random passcodes to PaseClient
   * Feature: Generalized Discovery logic and allow discoveries via different methods (BLE+IP) in parallel
   * Feature: Added functionality to clear session contexts including data in sub-contexts or not
+  * Feature: Enhance discovery methods to allow continuous discovery for operational devices
 * matter.js API:
   * Breaking: Rename resetStorage() on CommissioningServer to factoryReset() and add logic to restart the device if currently running
   * Breaking: Restructure the CommissioningController to allow pairing with multiple nodes
     * Adjusts some property and structure namings to be more consistent
     * Introducing class PairedNode with the High level API for a paired Node
     * Restructured CommissioningController to handle multiple nodes and offer new high level API
     * Changed name of the unique storage id for servers or controllers added to MatterServer to "uniqueStorageKey"
+    * Adjusted subscription callbacks to also provide the nodeId of the affected device reporting the changes to allow callbacks to be used generically when connecting to all nodes
+    * Introduces a node state information callback to inform about the connection status but also when the node structure changed (for bridges) or such.
+  * Feature: Enhanced CommissioningServer API and CommissioningController for improved practical usage
   * Feature: Makes Port for CommissioningServer optional and add automatic port handling in MatterServer
   * Feature: Allows removal of Controller or Server instances from Matter server, optionally with deleting the storage
   * Enhance: Makes passcode and discriminator for CommissioningServer optional and randomly generate them if not provided 

packages/matter-node-ble.js/src/ble/BleScanner.ts

@@ -32,7 +32,10 @@ type CommissionableDeviceData = CommissionableDevice & {
 };
 
 export class BleScanner implements Scanner {
-    private readonly recordWaiters = new Map<string, { resolver: () => void; timer: Timer }>();
+    private readonly recordWaiters = new Map<
+        string,
+        { resolver: () => void; timer: Timer; resolveOnUpdatedRecords: boolean }
+    >();
     private readonly discoveredMatterDevices = new Map<string, DiscoveredBleDevice>();
 
     constructor(private readonly nobleClient: NobleBleClient) {
@@ -53,22 +56,27 @@ export class BleScanner implements Scanner {
      * Registers a deferred promise for a specific queryId together with a timeout and return the promise.
      * The promise will be resolved when the timer runs out latest.
      */
-    private async registerWaiterPromise(queryId: string, timeoutSeconds: number) {
+    private async registerWaiterPromise(queryId: string, timeoutSeconds: number, resolveOnUpdatedRecords = true) {
         const { promise, resolver } = createPromise<void>();
         const timer = Time.getTimer(timeoutSeconds * 1000, () => this.finishWaiter(queryId, true)).start();
-        this.recordWaiters.set(queryId, { resolver, timer });
-        logger.debug(`Registered waiter for query ${queryId} with timeout ${timeoutSeconds} seconds`);
+        this.recordWaiters.set(queryId, { resolver, timer, resolveOnUpdatedRecords });
+        logger.debug(
+            `Registered waiter for query ${queryId} with timeout ${timeoutSeconds} seconds${
+                resolveOnUpdatedRecords ? "" : " (not resolving on updated records)"
+            }`,
+        );
         return { promise };
     }
 
     /**
      * Remove a waiter promise for a specific queryId and stop the connected timer. If required also resolve the
      * promise.
      */
-    private finishWaiter(queryId: string, resolvePromise = false) {
+    private finishWaiter(queryId: string, resolvePromise: boolean, isUpdatedRecord = false) {
         const waiter = this.recordWaiters.get(queryId);
         if (waiter === undefined) return;
-        const { timer, resolver } = waiter;
+        const { timer, resolver, resolveOnUpdatedRecords } = waiter;
+        if (isUpdatedRecord && !resolveOnUpdatedRecords) return;
         logger.debug(`Finishing waiter for query ${queryId}, resolving: ${resolvePromise}`);
         timer.stop();
         if (resolvePromise) {
@@ -77,6 +85,11 @@ export class BleScanner implements Scanner {
         this.recordWaiters.delete(queryId);
     }
 
+    cancelCommissionableDeviceDiscovery(identifier: CommissionableDeviceIdentifiers) {
+        const queryKey = this.buildCommissionableQueryIdentifier(identifier);
+        this.finishWaiter(queryKey, true);
+    }
+
     private handleDiscoveredDevice(peripheral: Peripheral, manufacturerServiceData: ByteArray) {
         logger.debug(`Discovered device ${peripheral.address} ${manufacturerServiceData?.toHex()}`);
 
@@ -85,6 +98,7 @@ export class BleScanner implements Scanner {
                 BtpCodec.decodeBleAdvertisementServiceData(manufacturerServiceData);
 
             const commissionableDevice: CommissionableDeviceData = {
+                deviceIdentifier: peripheral.address,
                 D: discriminator,
                 SD: (discriminator >> 8) & 0x0f,
                 VP: `${vendorId}+${productId}`,
@@ -93,6 +107,8 @@ export class BleScanner implements Scanner {
             };
             logger.debug(`Discovered device ${peripheral.address} data: ${JSON.stringify(commissionableDevice)}`);
 
+            const deviceExisting = this.discoveredMatterDevices.has(peripheral.address);
+
             this.discoveredMatterDevices.set(peripheral.address, {
                 deviceData: commissionableDevice,
                 peripheral: peripheral,
@@ -101,7 +117,7 @@ export class BleScanner implements Scanner {
 
             const queryKey = this.findCommissionableQueryIdentifier(commissionableDevice);
             if (queryKey !== undefined) {
-                this.finishWaiter(queryKey, true);
+                this.finishWaiter(queryKey, true, deviceExisting);
             }
         } catch (error) {
             logger.debug(`Seems not to be a valid Matter device: Failed to decode device data: ${error}`);
@@ -217,12 +233,45 @@ export class BleScanner implements Scanner {
         return storedRecords.map(({ deviceData }) => deviceData);
     }
 
+    async findCommissionableDevicesContinuously(
+        identifier: CommissionableDeviceIdentifiers,
+        callback: (device: CommissionableDevice) => void,
+        timeoutSeconds = 60,
+    ): Promise<CommissionableDevice[]> {
+        const discoveredDevices = new Set<string>();
+
+        const discoveryEndTime = Time.nowMs() + timeoutSeconds * 1000;
+        const queryKey = this.buildCommissionableQueryIdentifier(identifier);
+        await this.nobleClient.startScanning();
+
+        while (true) {
+            this.getCommissionableDevices(identifier).forEach(({ deviceData }) => {
+                const { deviceIdentifier } = deviceData;
+                if (!discoveredDevices.has(deviceIdentifier)) {
+                    discoveredDevices.add(deviceIdentifier);
+                    callback(deviceData);
+                }
+            });
+
+            const remainingTime = Math.ceil((discoveryEndTime - Time.nowMs()) / 1000);
+            if (remainingTime <= 0) {
+                break;
+            }
+            const { promise } = await this.registerWaiterPromise(queryKey, remainingTime, false);
+            await promise;
+        }
+        await this.nobleClient.stopScanning();
+        return this.getCommissionableDevices(identifier).map(({ deviceData }) => deviceData);
+    }
+
     getDiscoveredCommissionableDevices(identifier: CommissionableDeviceIdentifiers): CommissionableDevice[] {
         return this.getCommissionableDevices(identifier).map(({ deviceData }) => deviceData);
     }
 
     close(): void {
         void this.nobleClient.stopScanning();
-        [...this.recordWaiters.keys()].forEach(queryId => this.finishWaiter(queryId, true));
+        [...this.recordWaiters.keys()].forEach(queryId =>
+            this.finishWaiter(queryId, !!this.recordWaiters.get(queryId)?.timer),
+        );
     }
 }

packages/matter-node-shell.js/src/MatterNode.ts

@@ -1,6 +1,9 @@
 /**
- * Import needed modules from @project-chip/matter-node.js
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
  */
+
 // Include this first to auto-register Crypto, Network and Time Node.js implementations
 import { CommissioningController, MatterServer } from "@project-chip/matter-node.js";
 
@@ -21,7 +24,7 @@ export class MatterNode {
     private storageContext?: StorageContext;
 
     commissioningController?: CommissioningController;
-    private matterDevice?: MatterServer;
+    private matterController?: MatterServer;
 
     constructor(private nodeNum: number) {}
 
@@ -52,7 +55,7 @@ export class MatterNode {
     }
 
     async close() {
-        await this.matterDevice?.close();
+        await this.matterController?.close();
         this.closeStorage();
     }
 
@@ -67,7 +70,7 @@ export class MatterNode {
         if (this.storageManager === undefined) {
             throw new Error("StorageManager not initialized"); // Should never happen
         }
-        if (this.matterDevice !== undefined) {
+        if (this.matterController !== undefined) {
             return;
         }
         logger.info(`matter.js shell controller started for node ${this.nodeNum}`);
@@ -85,11 +88,11 @@ export class MatterNode {
          * are called.
          */
 
-        this.matterDevice = new MatterServer(this.storageManager);
+        this.matterController = new MatterServer(this.storageManager);
         this.commissioningController = new CommissioningController({
             autoConnect: false,
         });
-        this.matterDevice.addCommissioningController(this.commissioningController);
+        this.matterController.addCommissioningController(this.commissioningController);
 
         /**
          * Start the Matter Server
@@ -98,7 +101,7 @@ export class MatterNode {
          * CommissioningServer node then this command also starts the announcement of the device into the network.
          */
 
-        await this.matterDevice.start();
+        await this.matterController.start();
     }
 
     async connectAndGetNodes(nodeIdStr?: string) {

packages/matter-node-shell.js/src/app.ts

@@ -1,17 +1,7 @@
 /**
- * Copyright 2022 Project CHIP Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *  https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
  */
 
 import { BleNode } from "@project-chip/matter-node-ble.js/ble";
@@ -85,7 +75,7 @@ async function main() {
 
                 const { nodeNum, ble, nodeType, resetStorage } = argv;
 
-                const theNode = new MatterNode(nodeNum);
+                theNode = new MatterNode(nodeNum);
                 await theNode.initialize(resetStorage);
                 const theShell = new Shell(theNode, PROMPT);
 

packages/matter-node-shell.js/src/shell/Shell.ts

@@ -1,17 +1,7 @@
 /**
- * Copyright 2022 Project CHIP Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *  https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
  */
 
 import { MatterError } from "@project-chip/matter-node.js/common";
@@ -22,6 +12,7 @@ import { MatterNode } from "../MatterNode.js";
 import { exit } from "../app";
 import cmdCommission from "./cmd_commission.js";
 import cmdConfig from "./cmd_config.js";
+import cmdDiscover from "./cmd_discover.js";
 import cmdIdentify from "./cmd_identify.js";
 import cmdLock from "./cmd_lock.js";
 import cmdNodes from "./cmd_nodes.js";
@@ -55,7 +46,6 @@ export class Shell {
      *
      * @param {MatterNode} theNode MatterNode object to use for all commands.
      * @param {string} prompt Prompt string to use for each command line.
-     * @param {Array} commandList Array of JSON commands dispatch structures.
      */
     constructor(
         public theNode: MatterNode,
@@ -77,8 +67,12 @@ export class Shell {
                 });
             })
             .on("close", () => {
-                process.stdout.write("goodbye\n");
-                process.exit(0);
+                exit()
+                    .then(() => process.exit(0))
+                    .catch(e => {
+                        process.stderr.write(`Close error: ${e}\n`);
+                        process.exit(1);
+                    });
             });
 
         this.readline.prompt();
@@ -102,6 +96,7 @@ export class Shell {
                     cmdOnOff(this.theNode),
                     cmdSubscribe(this.theNode),
                     cmdIdentify(this.theNode),
+                    cmdDiscover(this.theNode),
                     exitCommand(),
                 ])
                 .command({
@@ -124,6 +119,8 @@ export class Shell {
                 if (argv.unhandled) {
                     process.stderr.write(`Unknown command: ${line}\n`);
                     yargsInstance.showHelp();
+                } else {
+                    console.log("Done.");
                 }
             } catch (error) {
                 process.stderr.write(`Error happened during command: ${error}\n`);