@matter/protocol 0.12.0-alpha.0-20250101-22e7c1044 → 0.12.0-alpha.0-20250107-af5a068c3

package/src/peer/ControllerCommissioningFlow.ts

@@ -142,7 +142,10 @@ export class ControllerCommissioningFlow {
     #interactionClient: InteractionClient;
     readonly #ca: CertificateAuthority;
     readonly #fabric: Fabric;
-    readonly #transitionToCase: (peerAddress: PeerAddress) => Promise<InteractionClient | undefined>;
+    readonly #transitionToCase: (
+        peerAddress: PeerAddress,
+        supportsConcurrentConnections: boolean,
+    ) => Promise<InteractionClient | undefined>;
     readonly #commissioningOptions: ControllerCommissioningFlowOptions;
     readonly #commissioningSteps = new Array<CommissioningStep>();
     readonly #commissioningStepResults = new Map<string, CommissioningStepResult>();
@@ -168,7 +171,10 @@ export class ControllerCommissioningFlow {
         commissioningOptions: ControllerCommissioningFlowOptions,
 
         /** Callback that establishes CASE connection or handles final commissioning */
-        transitionToCase: (peerAddress: PeerAddress) => Promise<InteractionClient | undefined>,
+        transitionToCase: (
+            peerAddress: PeerAddress,
+            supportsConcurrentConnections: boolean,
+        ) => Promise<InteractionClient | undefined>,
     ) {
         this.#interactionClient = interactionClient;
         this.#ca = ca;
@@ -1144,7 +1150,11 @@ export class ControllerCommissioningFlow {
      */
     async #reconnectWithDevice() {
         logger.debug("Reconnecting with device ...");
-        const transitionResult = await this.#transitionToCase(this.#interactionClient.address);
+        const transitionResult = await this.#transitionToCase(
+            this.#interactionClient.address,
+            // Assume concurrent connections are supported if not know (which should not be the case when we came here)
+            this.#collectedCommissioningData.supportsConcurrentConnection ?? true,
+        );
 
         if (transitionResult === undefined) {
             logger.debug("CASE commissioning handled externally, terminating commissioning flow");

package/src/peer/ControllerDiscovery.ts

@@ -43,7 +43,11 @@ export class ControllerDiscovery {
         logger.info(`Start Discovering devices using identifier ${Logger.toJSON(identifier)} ...`);
 
         const scanResults = scanners.map(async scanner => {
-            const foundDevices = await scanner.findCommissionableDevices(identifier, timeoutSeconds);
+            const foundDevices = await scanner.findCommissionableDevices(
+                identifier,
+                timeoutSeconds,
+                scanner.type === "ble", // Force rediscovery for BLE
+            );
             logger.info(`Found ${foundDevices.length} devices using identifier ${Logger.toJSON(identifier)}`);
             if (foundDevices.length === 0) {
                 throw new CommissioningError(

package/src/protocol/DeviceAdvertiser.ts

@@ -39,6 +39,7 @@ export class DeviceAdvertiser {
     readonly #context: DeviceAdvertiserContext;
     readonly #broadcasters = new Set<InstanceBroadcaster>();
     readonly #timedOut = AsyncObservable<[]>();
+    readonly #operationalModeEnabled = new AsyncObservable<[]>();
     readonly #operationalModeEnded = new AsyncObservable<[]>();
     readonly #observers = new ObserverGroup();
     #interval: Timer;
@@ -103,6 +104,13 @@ export class DeviceAdvertiser {
         return this.#operationalModeEnded;
     }
 
+    /**
+     * Emitted when the device starts advertising in operational mode.
+     */
+    get operationalModeEnabled() {
+        return this.#operationalModeEnabled;
+    }
+
     async enterCommissioningMode(mode: CommissioningMode, deviceData: CommissioningModeInstanceData) {
         this.#commissioningMode = mode;
         for (const broadcaster of this.#broadcasters) {
@@ -173,6 +181,12 @@ export class DeviceAdvertiser {
     }
 
     async advertiseFabrics(fabrics: Fabric[], expireCommissioningAnnouncement = false) {
+        if (expireCommissioningAnnouncement) {
+            // TODO: For real "non-ethernet-only" cases like Wifi or Thread devices this might still be too early.
+            //  In these cases we might need an option to (re-)create mdns broadcaster just when interface
+            //  is connected
+            await this.#operationalModeEnabled.emit();
+        }
         for (const broadcaster of this.#broadcasters) {
             await broadcaster.setFabrics(fabrics, expireCommissioningAnnouncement);
             await broadcaster.announce();