@matter/react-native 0.11.0-alpha.0-20241005-e3e4e4a7a

package/package.json

@@ -0,0 +1,105 @@
+{
+    "name": "@matter/react-native",
+    "version": "0.11.0-alpha.0-20241005-e3e4e4a7a",
+    "description": "Experimental React Native support for matter.js",
+    "keywords": [
+        "iot",
+        "home automation",
+        "matter",
+        "smart device",
+        "ble"
+    ],
+    "license": "Apache-2.0",
+    "author": "matter.js authors",
+    "contributors": [
+        "Ingo Fischer <github@fischer-ka.de>"
+    ],
+    "bugs": {
+        "url": "https://github.com/project-chip/matter.js/issues"
+    },
+    "homepage": "https://github.com/project-chip/matter.js",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/project-chip/matter.js.git"
+    },
+    "scripts": {
+        "clean": "matter-build clean",
+        "build": "matter-build",
+        "build-clean": "matter-build --clean",
+        "build-doc": "typedoc --excludeExternals --plugin typedoc-plugin-missing-exports --plugin typedoc-plugin-markdown --tsconfig src/tsconfig.json"
+    },
+    "imports": {
+        "#general": "@matter/general",
+        "#types": "@matter/types",
+        "#protocol": "@matter/protocol",
+        "#nodejs": "@matter/nodejs",
+        "#*": "./src/*"
+    },
+    "dependencies": {
+        "@matter/nodejs": "0.11.0-alpha.0-20241005-e3e4e4a7a",
+        "@matter/general": "0.11.0-alpha.0-20241005-e3e4e4a7a",
+        "@matter/protocol": "0.11.0-alpha.0-20241005-e3e4e4a7a",
+        "@react-native-async-storage/async-storage": "^2.0.0",
+        "@react-native-community/netinfo": "^11.3.2",
+        "@types/jwk-to-pem": "^2.0.3",
+        "@types/node": "^22.7.4",
+        "jwk-to-pem": "^2.0.5",
+        "react-native-ble-plx": "^3.2.1",
+        "react-native-polyfill-globals": "^3.1.0",
+        "react-native-quick-crypto": "^0.7.4",
+        "react-native-udp": "^4.1.7"
+    },
+    "devDependencies": {
+        "@matter/tools": "0.11.0-alpha.0-20241005-e3e4e4a7a"
+    },
+    "overrides": {
+        "brorand": "npm:@matter.js/brorand@1.1.0"
+    },
+    "files": [
+        "dist/**/*",
+        "src/**/*",
+        "require/**/*",
+        "LICENSE",
+        "README.md"
+    ],
+    "type": "module",
+    "main": "dist/cjs/export.js",
+    "module": "dist/esm/export.js",
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./dist/esm/export.d.ts",
+                "default": "./dist/esm/export.js"
+            },
+            "require": {
+                "types": "./dist/cjs/export.d.ts",
+                "default": "./dist/cjs/export.js"
+            }
+        },
+        "./package.json": "./package.json",
+        "./*": {
+            "import": {
+                "types": "./dist/esm/*/export.d.ts",
+                "default": "./dist/esm/*/export.js"
+            },
+            "require": {
+                "types": "./dist/cjs/*/export.d.ts",
+                "default": "./dist/cjs/*/export.js"
+            }
+        }
+    },
+    "types": "dist/esm/export.d.ts",
+    "typesVersions": {
+        "*": {
+            ".": [
+                "/dist/cjs/export.d.ts"
+            ],
+            "*": [
+                "/dist/cjs/*/export.d.ts"
+            ]
+        }
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/src/ble/BleReactNative.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ChannelType, ImplementationError, NetInterface, TransportInterface } from "#general";
+import { Ble, InstanceBroadcaster, Scanner } from "#protocol";
+import { BleScanner } from "./BleScanner.js";
+import { ReactNativeBleCentralInterface } from "./ReactNativeBleChannel.js";
+import { ReactNativeBleClient } from "./ReactNativeBleClient.js";
+
+export class BleReactNative extends Ble {
+    private bleCentral: ReactNativeBleClient | undefined;
+
+    constructor() {
+        super();
+    }
+
+    getBleCentralInterface(): NetInterface {
+        if (this.bleCentral === undefined) {
+            this.bleCentral = new ReactNativeBleClient();
+        }
+        return new ReactNativeBleCentralInterface();
+    }
+
+    getBleScanner(): Scanner {
+        if (this.bleCentral === undefined) {
+            this.bleCentral = new ReactNativeBleClient();
+        }
+        return new BleScanner(this.bleCentral);
+    }
+
+    getBlePeripheralInterface(): TransportInterface {
+        throw new ImplementationError("React Native can only act as a central device, not a peripheral.");
+    }
+
+    getBleBroadcaster(): InstanceBroadcaster {
+        throw new ImplementationError("React Native can only act as a central device, not a broadcaster.");
+    }
+
+    supports(type: ChannelType) {
+        return type === ChannelType.BLE;
+    }
+}

package/src/ble/BleScanner.ts

@@ -0,0 +1,277 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Bytes, ChannelType, createPromise, Logger, Time, Timer } from "#general";
+import { BleError, BtpCodec, CommissionableDevice, CommissionableDeviceIdentifiers, Scanner } from "#protocol";
+import { VendorId } from "#types";
+import { Device } from "react-native-ble-plx";
+import { ReactNativeBleClient } from "./ReactNativeBleClient.js";
+
+const logger = Logger.get("BleScanner");
+
+export type DiscoveredBleDevice = {
+    deviceData: CommissionableDeviceData;
+    peripheral: Device;
+    hasAdditionalAdvertisementData: boolean;
+};
+
+type CommissionableDeviceData = CommissionableDevice & {
+    SD: number; // Additional Field for Short discriminator
+};
+
+export class BleScanner implements Scanner {
+    get type() {
+        return ChannelType.BLE;
+    }
+
+    private readonly recordWaiters = new Map<
+        string,
+        {
+            resolver: () => void;
+            timer: Timer;
+            resolveOnUpdatedRecords: boolean;
+        }
+    >();
+    private readonly discoveredMatterDevices = new Map<string, DiscoveredBleDevice>();
+
+    constructor(private readonly bleClient: ReactNativeBleClient) {
+        this.bleClient.setDiscoveryCallback((address, manufacturerData) =>
+            this.handleDiscoveredDevice(address, manufacturerData),
+        );
+    }
+
+    public getDiscoveredDevice(address: string): DiscoveredBleDevice {
+        const device = this.discoveredMatterDevices.get(address);
+        if (device === undefined) {
+            throw new BleError(`No device found for address ${address}`);
+        }
+        return device;
+    }
+
+    /**
+     * 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, resolveOnUpdatedRecords = true) {
+        const { promise, resolver } = createPromise<void>();
+        const timer = Time.getTimer("BLE query timeout", timeoutSeconds * 1000, () =>
+            this.finishWaiter(queryId, true),
+        ).start();
+        this.recordWaiters.set(queryId, { resolver, timer, resolveOnUpdatedRecords });
+        logger.debug(
+            `Registered waiter for query ${queryId} with timeout ${timeoutSeconds} seconds${
+                resolveOnUpdatedRecords ? "" : " (not resolving on updated records)"
+            }`,
+        );
+        await 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: boolean, isUpdatedRecord = false) {
+        const waiter = this.recordWaiters.get(queryId);
+        if (waiter === undefined) return;
+        const { timer, resolver, resolveOnUpdatedRecords } = waiter;
+        if (isUpdatedRecord && !resolveOnUpdatedRecords) return;
+        logger.debug(`Finishing waiter for query ${queryId}, resolving: ${resolvePromise}`);
+        timer.stop();
+        if (resolvePromise) {
+            resolver();
+        }
+        this.recordWaiters.delete(queryId);
+    }
+
+    cancelCommissionableDeviceDiscovery(identifier: CommissionableDeviceIdentifiers) {
+        const queryKey = this.buildCommissionableQueryIdentifier(identifier);
+        this.finishWaiter(queryKey, true);
+    }
+
+    private handleDiscoveredDevice(peripheral: Device, manufacturerServiceData: Uint8Array) {
+        logger.debug(
+            `Discovered device ${peripheral.id} "${peripheral.localName}" ${manufacturerServiceData === undefined ? undefined : Bytes.toHex(manufacturerServiceData)}`,
+        );
+
+        try {
+            const { discriminator, vendorId, productId, hasAdditionalAdvertisementData } =
+                BtpCodec.decodeBleAdvertisementServiceData(manufacturerServiceData);
+
+            const commissionableDevice: CommissionableDeviceData = {
+                deviceIdentifier: peripheral.id,
+                D: discriminator,
+                SD: (discriminator >> 8) & 0x0f,
+                VP: `${vendorId}+${productId}`,
+                CM: 1, // Can be no other mode,
+                addresses: [{ type: "ble", peripheralAddress: peripheral.id }],
+            };
+            logger.debug(`Discovered device ${peripheral.id} data: ${JSON.stringify(commissionableDevice)}`);
+
+            const deviceExisting = this.discoveredMatterDevices.has(peripheral.id);
+
+            this.discoveredMatterDevices.set(peripheral.id, {
+                deviceData: commissionableDevice,
+                peripheral: peripheral,
+                hasAdditionalAdvertisementData,
+            });
+
+            const queryKey = this.findCommissionableQueryIdentifier(commissionableDevice);
+            if (queryKey !== undefined) {
+                this.finishWaiter(queryKey, true, deviceExisting);
+            }
+        } catch (error) {
+            logger.debug(`Seems not to be a valid Matter device: Failed to decode device data: ${error}`);
+        }
+    }
+
+    private findCommissionableQueryIdentifier(record: CommissionableDeviceData) {
+        const longDiscriminatorQueryId = this.buildCommissionableQueryIdentifier({ longDiscriminator: record.D });
+        if (this.recordWaiters.has(longDiscriminatorQueryId)) {
+            return longDiscriminatorQueryId;
+        }
+
+        const shortDiscriminatorQueryId = this.buildCommissionableQueryIdentifier({ shortDiscriminator: record.SD });
+        if (this.recordWaiters.has(shortDiscriminatorQueryId)) {
+            return shortDiscriminatorQueryId;
+        }
+
+        if (record.VP !== undefined) {
+            const vendorIdQueryId = this.buildCommissionableQueryIdentifier({
+                vendorId: VendorId(parseInt(record.VP.split("+")[0])),
+            });
+            if (this.recordWaiters.has(vendorIdQueryId)) {
+                return vendorIdQueryId;
+            }
+            if (record.VP.includes("+")) {
+                const productIdQueryId = this.buildCommissionableQueryIdentifier({
+                    vendorId: VendorId(parseInt(record.VP.split("+")[1])),
+                });
+                if (this.recordWaiters.has(productIdQueryId)) {
+                    return productIdQueryId;
+                }
+            }
+        }
+
+        if (this.recordWaiters.has("*")) {
+            return "*";
+        }
+
+        return undefined;
+    }
+
+    /**
+     * Builds an identifier string for commissionable queries based on the given identifier object.
+     * Some identifiers are identical to the official DNS-SD identifiers, others are custom.
+     */
+    private buildCommissionableQueryIdentifier(identifier: CommissionableDeviceIdentifiers) {
+        if ("longDiscriminator" in identifier) {
+            return `D:${identifier.longDiscriminator}`;
+        } else if ("shortDiscriminator" in identifier) {
+            return `SD:${identifier.shortDiscriminator}`;
+        } else if ("vendorId" in identifier) {
+            return `V:${identifier.vendorId}`;
+        } else if ("productId" in identifier) {
+            // Custom identifier because normally productId is only included in TXT record
+            return `P:${identifier.productId}`;
+        } else return "*";
+    }
+
+    private getCommissionableDevices(identifier: CommissionableDeviceIdentifiers) {
+        const storedRecords = Array.from(this.discoveredMatterDevices.values());
+
+        const foundRecords = new Array<DiscoveredBleDevice>();
+        if ("longDiscriminator" in identifier) {
+            foundRecords.push(...storedRecords.filter(({ deviceData: { D } }) => D === identifier.longDiscriminator));
+        } else if ("shortDiscriminator" in identifier) {
+            foundRecords.push(
+                ...storedRecords.filter(({ deviceData: { SD } }) => SD === identifier.shortDiscriminator),
+            );
+        } else if ("vendorId" in identifier) {
+            foundRecords.push(
+                ...storedRecords.filter(
+                    ({ deviceData: { VP } }) =>
+                        VP === `${identifier.vendorId}` || VP?.startsWith(`${identifier.vendorId}+`),
+                ),
+            );
+        } else if ("productId" in identifier) {
+            foundRecords.push(
+                ...storedRecords.filter(({ deviceData: { VP } }) => VP?.endsWith(`+${identifier.productId}`)),
+            );
+        } else {
+            foundRecords.push(...storedRecords.filter(({ deviceData: { CM } }) => CM === 1 || CM === 2));
+        }
+
+        return foundRecords;
+    }
+
+    async findOperationalDevice(): Promise<undefined> {
+        logger.info(`skip BLE scan because scanning for operational devices is not supported`);
+        return undefined;
+    }
+
+    getDiscoveredOperationalDevice(): undefined {
+        logger.info(`skip BLE scan because scanning for operational devices is not supported`);
+        return undefined;
+    }
+
+    async findCommissionableDevices(
+        identifier: CommissionableDeviceIdentifiers,
+        timeoutSeconds = 10,
+    ): Promise<CommissionableDevice[]> {
+        let storedRecords = this.getCommissionableDevices(identifier);
+        if (storedRecords.length === 0) {
+            const queryKey = this.buildCommissionableQueryIdentifier(identifier);
+
+            await this.bleClient.startScanning();
+            await this.registerWaiterPromise(queryKey, timeoutSeconds);
+
+            storedRecords = this.getCommissionableDevices(identifier);
+            await this.bleClient.stopScanning();
+        }
+        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.bleClient.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;
+            }
+            await this.registerWaiterPromise(queryKey, remainingTime, false);
+        }
+        await this.bleClient.stopScanning();
+        return this.getCommissionableDevices(identifier).map(({ deviceData }) => deviceData);
+    }
+
+    getDiscoveredCommissionableDevices(identifier: CommissionableDeviceIdentifiers): CommissionableDevice[] {
+        return this.getCommissionableDevices(identifier).map(({ deviceData }) => deviceData);
+    }
+
+    close(): void {
+        void this.bleClient.stopScanning();
+        [...this.recordWaiters.keys()].forEach(queryId =>
+            this.finishWaiter(queryId, !!this.recordWaiters.get(queryId)?.timer),
+        );
+    }
+}