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

package/dist/esm/ble/BleReactNative.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ChannelType, NetInterface, TransportInterface } from "#general";
+import { Ble, InstanceBroadcaster, Scanner } from "#protocol";
+export declare class BleReactNative extends Ble {
+    private bleCentral;
+    constructor();
+    getBleCentralInterface(): NetInterface;
+    getBleScanner(): Scanner;
+    getBlePeripheralInterface(): TransportInterface;
+    getBleBroadcaster(): InstanceBroadcaster;
+    supports(type: ChannelType): type is ChannelType.BLE;
+}
+//# sourceMappingURL=BleReactNative.d.ts.map

package/dist/esm/ble/BleReactNative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BleReactNative.d.ts","sourceRoot":"","sources":["../../../src/ble/BleReactNative.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAuB,YAAY,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9F,OAAO,EAAE,GAAG,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAK9D,qBAAa,cAAe,SAAQ,GAAG;IACnC,OAAO,CAAC,UAAU,CAAmC;;IAMrD,sBAAsB,IAAI,YAAY;IAOtC,aAAa,IAAI,OAAO;IAOxB,yBAAyB,IAAI,kBAAkB;IAI/C,iBAAiB,IAAI,mBAAmB;IAIxC,QAAQ,CAAC,IAAI,EAAE,WAAW;CAG7B"}

package/dist/esm/ble/BleReactNative.js

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

package/dist/esm/ble/BleReactNative.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/ble/BleReactNative.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,aAAa,2BAA6D;AACnF,SAAS,WAAyC;AAClD,SAAS,kBAAkB;AAC3B,SAAS,sCAAsC;AAC/C,SAAS,4BAA4B;AAE9B,MAAM,uBAAuB,IAAI;AAAA,EAC5B;AAAA,EAER,cAAc;AACV,UAAM;AAAA,EACV;AAAA,EAEA,yBAAuC;AACnC,QAAI,KAAK,eAAe,QAAW;AAC/B,WAAK,aAAa,IAAI,qBAAqB;AAAA,IAC/C;AACA,WAAO,IAAI,+BAA+B;AAAA,EAC9C;AAAA,EAEA,gBAAyB;AACrB,QAAI,KAAK,eAAe,QAAW;AAC/B,WAAK,aAAa,IAAI,qBAAqB;AAAA,IAC/C;AACA,WAAO,IAAI,WAAW,KAAK,UAAU;AAAA,EACzC;AAAA,EAEA,4BAAgD;AAC5C,UAAM,IAAI,oBAAoB,kEAAkE;AAAA,EACpG;AAAA,EAEA,oBAAyC;AACrC,UAAM,IAAI,oBAAoB,mEAAmE;AAAA,EACrG;AAAA,EAEA,SAAS,MAAmB;AACxB,WAAO,SAAS,YAAY;AAAA,EAChC;AACJ;",
+  "names": []
+}

package/dist/esm/ble/BleScanner.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ChannelType } from "#general";
+import { CommissionableDevice, CommissionableDeviceIdentifiers, Scanner } from "#protocol";
+import { Device } from "react-native-ble-plx";
+import { ReactNativeBleClient } from "./ReactNativeBleClient.js";
+export type DiscoveredBleDevice = {
+    deviceData: CommissionableDeviceData;
+    peripheral: Device;
+    hasAdditionalAdvertisementData: boolean;
+};
+type CommissionableDeviceData = CommissionableDevice & {
+    SD: number;
+};
+export declare class BleScanner implements Scanner {
+    private readonly bleClient;
+    get type(): ChannelType;
+    private readonly recordWaiters;
+    private readonly discoveredMatterDevices;
+    constructor(bleClient: ReactNativeBleClient);
+    getDiscoveredDevice(address: string): DiscoveredBleDevice;
+    /**
+     * 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 registerWaiterPromise;
+    /**
+     * Remove a waiter promise for a specific queryId and stop the connected timer. If required also resolve the
+     * promise.
+     */
+    private finishWaiter;
+    cancelCommissionableDeviceDiscovery(identifier: CommissionableDeviceIdentifiers): void;
+    private handleDiscoveredDevice;
+    private findCommissionableQueryIdentifier;
+    /**
+     * 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;
+    private getCommissionableDevices;
+    findOperationalDevice(): Promise<undefined>;
+    getDiscoveredOperationalDevice(): undefined;
+    findCommissionableDevices(identifier: CommissionableDeviceIdentifiers, timeoutSeconds?: number): Promise<CommissionableDevice[]>;
+    findCommissionableDevicesContinuously(identifier: CommissionableDeviceIdentifiers, callback: (device: CommissionableDevice) => void, timeoutSeconds?: number): Promise<CommissionableDevice[]>;
+    getDiscoveredCommissionableDevices(identifier: CommissionableDeviceIdentifiers): CommissionableDevice[];
+    close(): void;
+}
+export {};
+//# sourceMappingURL=BleScanner.d.ts.map

package/dist/esm/ble/BleScanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BleScanner.d.ts","sourceRoot":"","sources":["../../../src/ble/BleScanner.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAS,WAAW,EAAsC,MAAM,UAAU,CAAC;AAClF,OAAO,EAAsB,oBAAoB,EAAE,+BAA+B,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAE/G,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAIjE,MAAM,MAAM,mBAAmB,GAAG;IAC9B,UAAU,EAAE,wBAAwB,CAAC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,8BAA8B,EAAE,OAAO,CAAC;CAC3C,CAAC;AAEF,KAAK,wBAAwB,GAAG,oBAAoB,GAAG;IACnD,EAAE,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,qBAAa,UAAW,YAAW,OAAO;IAe1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAdtC,IAAI,IAAI,gBAEP;IAED,OAAO,CAAC,QAAQ,CAAC,aAAa,CAO1B;IACJ,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAA0C;gBAErD,SAAS,EAAE,oBAAoB;IAMrD,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB;IAQhE;;;OAGG;YACW,qBAAqB;IAcnC;;;OAGG;IACH,OAAO,CAAC,YAAY;IAapB,mCAAmC,CAAC,UAAU,EAAE,+BAA+B;IAK/E,OAAO,CAAC,sBAAsB;IAoC9B,OAAO,CAAC,iCAAiC;IAmCzC;;;OAGG;IACH,OAAO,CAAC,kCAAkC;IAa1C,OAAO,CAAC,wBAAwB;IA4B1B,qBAAqB,IAAI,OAAO,CAAC,SAAS,CAAC;IAKjD,8BAA8B,IAAI,SAAS;IAKrC,yBAAyB,CAC3B,UAAU,EAAE,+BAA+B,EAC3C,cAAc,SAAK,GACpB,OAAO,CAAC,oBAAoB,EAAE,CAAC;IAc5B,qCAAqC,CACvC,UAAU,EAAE,+BAA+B,EAC3C,QAAQ,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,EAChD,cAAc,SAAK,GACpB,OAAO,CAAC,oBAAoB,EAAE,CAAC;IA0BlC,kCAAkC,CAAC,UAAU,EAAE,+BAA+B,GAAG,oBAAoB,EAAE;IAIvG,KAAK,IAAI,IAAI;CAMhB"}

package/dist/esm/ble/BleScanner.js

@@ -0,0 +1,219 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bytes, ChannelType, createPromise, Logger, Time } from "#general";
+import { BleError, BtpCodec } from "#protocol";
+import { VendorId } from "#types";
+const logger = Logger.get("BleScanner");
+class BleScanner {
+  constructor(bleClient) {
+    this.bleClient = bleClient;
+    this.bleClient.setDiscoveryCallback(
+      (address, manufacturerData) => this.handleDiscoveredDevice(address, manufacturerData)
+    );
+  }
+  get type() {
+    return ChannelType.BLE;
+  }
+  recordWaiters = /* @__PURE__ */ new Map();
+  discoveredMatterDevices = /* @__PURE__ */ new Map();
+  getDiscoveredDevice(address) {
+    const device = this.discoveredMatterDevices.get(address);
+    if (device === void 0) {
+      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.
+   */
+  async registerWaiterPromise(queryId, timeoutSeconds, resolveOnUpdatedRecords = true) {
+    const { promise, resolver } = createPromise();
+    const timer = Time.getTimer(
+      "BLE query timeout",
+      timeoutSeconds * 1e3,
+      () => 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.
+   */
+  finishWaiter(queryId, resolvePromise, isUpdatedRecord = false) {
+    const waiter = this.recordWaiters.get(queryId);
+    if (waiter === void 0) 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) {
+    const queryKey = this.buildCommissionableQueryIdentifier(identifier);
+    this.finishWaiter(queryKey, true);
+  }
+  handleDiscoveredDevice(peripheral, manufacturerServiceData) {
+    logger.debug(
+      `Discovered device ${peripheral.id} "${peripheral.localName}" ${manufacturerServiceData === void 0 ? void 0 : Bytes.toHex(manufacturerServiceData)}`
+    );
+    try {
+      const { discriminator, vendorId, productId, hasAdditionalAdvertisementData } = BtpCodec.decodeBleAdvertisementServiceData(manufacturerServiceData);
+      const commissionableDevice = {
+        deviceIdentifier: peripheral.id,
+        D: discriminator,
+        SD: discriminator >> 8 & 15,
+        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,
+        hasAdditionalAdvertisementData
+      });
+      const queryKey = this.findCommissionableQueryIdentifier(commissionableDevice);
+      if (queryKey !== void 0) {
+        this.finishWaiter(queryKey, true, deviceExisting);
+      }
+    } catch (error) {
+      logger.debug(`Seems not to be a valid Matter device: Failed to decode device data: ${error}`);
+    }
+  }
+  findCommissionableQueryIdentifier(record) {
+    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 !== void 0) {
+      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 void 0;
+  }
+  /**
+   * 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.
+   */
+  buildCommissionableQueryIdentifier(identifier) {
+    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) {
+      return `P:${identifier.productId}`;
+    } else return "*";
+  }
+  getCommissionableDevices(identifier) {
+    const storedRecords = Array.from(this.discoveredMatterDevices.values());
+    const foundRecords = new Array();
+    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() {
+    logger.info(`skip BLE scan because scanning for operational devices is not supported`);
+    return void 0;
+  }
+  getDiscoveredOperationalDevice() {
+    logger.info(`skip BLE scan because scanning for operational devices is not supported`);
+    return void 0;
+  }
+  async findCommissionableDevices(identifier, timeoutSeconds = 10) {
+    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, callback, timeoutSeconds = 60) {
+    const discoveredDevices = /* @__PURE__ */ new Set();
+    const discoveryEndTime = Time.nowMs() + timeoutSeconds * 1e3;
+    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()) / 1e3);
+      if (remainingTime <= 0) {
+        break;
+      }
+      await this.registerWaiterPromise(queryKey, remainingTime, false);
+    }
+    await this.bleClient.stopScanning();
+    return this.getCommissionableDevices(identifier).map(({ deviceData }) => deviceData);
+  }
+  getDiscoveredCommissionableDevices(identifier) {
+    return this.getCommissionableDevices(identifier).map(({ deviceData }) => deviceData);
+  }
+  close() {
+    void this.bleClient.stopScanning();
+    [...this.recordWaiters.keys()].forEach(
+      (queryId) => this.finishWaiter(queryId, !!this.recordWaiters.get(queryId)?.timer)
+    );
+  }
+}
+export {
+  BleScanner
+};
+//# sourceMappingURL=BleScanner.js.map

package/dist/esm/ble/BleScanner.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/ble/BleScanner.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/ble/ReactNativeBleChannel.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Channel, ChannelType, NetInterface, ServerAddress, TransportInterface } from "#general";
+import { BleChannel, BtpSessionHandler } from "#protocol";
+import { Characteristic, Device } from "react-native-ble-plx";
+export declare class ReactNativeBleCentralInterface implements NetInterface {
+    private openChannels;
+    private onMatterMessageListener;
+    openChannel(address: ServerAddress): Promise<Channel<Uint8Array>>;
+    onData(listener: (socket: Channel<Uint8Array>, data: Uint8Array) => void): TransportInterface.Listener;
+    close(): Promise<void>;
+    supports(type: ChannelType): type is ChannelType.BLE;
+}
+export declare class ReactNativeBleChannel extends BleChannel<Uint8Array> {
+    private readonly peripheral;
+    private readonly btpSession;
+    static create(peripheral: Device, characteristicC1ForWrite: Characteristic, characteristicC2ForSubscribe: Characteristic, onMatterMessageListener: (socket: Channel<Uint8Array>, data: Uint8Array) => void, _additionalCommissioningRelatedData?: Uint8Array): Promise<ReactNativeBleChannel>;
+    private connected;
+    private disconnectSubscription;
+    constructor(peripheral: Device, btpSession: BtpSessionHandler);
+    /**
+     * Send a Matter message to the connected device - need to do BTP assembly first.
+     *
+     * @param data
+     */
+    send(data: Uint8Array): Promise<void>;
+    get name(): string;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=ReactNativeBleChannel.d.ts.map

package/dist/esm/ble/ReactNativeBleChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactNativeBleChannel.d.ts","sourceRoot":"","sources":["../../../src/ble/ReactNativeBleChannel.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAEH,OAAO,EACP,WAAW,EAGX,YAAY,EACZ,aAAa,EAEb,kBAAkB,EAErB,MAAM,UAAU,CAAC;AAClB,OAAO,EAUH,UAAU,EAIV,iBAAiB,EACpB,MAAM,WAAW,CAAC;AACnB,OAAO,EAEH,cAAc,EACd,MAAM,EAGT,MAAM,sBAAsB,CAAC;AAK9B,qBAAa,8BAA+B,YAAW,YAAY;IAC/D,OAAO,CAAC,YAAY,CAAyC;IAC7D,OAAO,CAAC,uBAAuB,CAAwE;IAEjG,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IA6FvE,MAAM,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI,GAAG,kBAAkB,CAAC,QAAQ;IAOhG,KAAK;IAMX,QAAQ,CAAC,IAAI,EAAE,WAAW;CAG7B;AAED,qBAAa,qBAAsB,SAAQ,UAAU,CAAC,UAAU,CAAC;IAkHzD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;WAlHlB,MAAM,CACf,UAAU,EAAE,MAAM,EAClB,wBAAwB,EAAE,cAAc,EACxC,4BAA4B,EAAE,cAAc,EAC5C,uBAAuB,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI,EAChF,mCAAmC,CAAC,EAAE,UAAU,GACjD,OAAO,CAAC,qBAAqB,CAAC;IAuGjC,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,sBAAsB,CAAe;gBAGxB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,iBAAiB;IAWlD;;;;OAIG;IACG,IAAI,CAAC,IAAI,EAAE,UAAU;IAY3B,IAAI,IAAI,WAEP;IAEK,KAAK;CAKd"}

package/dist/esm/ble/ReactNativeBleChannel.js

@@ -0,0 +1,257 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  Bytes,
+  ChannelType,
+  InternalError,
+  Logger,
+  Time,
+  createPromise
+} from "#general";
+import {
+  BLE_MATTER_C1_CHARACTERISTIC_UUID,
+  BLE_MATTER_C2_CHARACTERISTIC_UUID,
+  BLE_MATTER_C3_CHARACTERISTIC_UUID,
+  BLE_MATTER_SERVICE_UUID,
+  BLE_MAXIMUM_BTP_MTU,
+  BTP_CONN_RSP_TIMEOUT_MS,
+  BTP_MAXIMUM_WINDOW_SIZE,
+  BTP_SUPPORTED_VERSIONS,
+  Ble,
+  BleChannel,
+  BleError,
+  BtpCodec,
+  BtpFlowError,
+  BtpSessionHandler
+} from "#protocol";
+import {
+  BleErrorCode,
+  BleError as ReactNativeBleError
+} from "react-native-ble-plx";
+const logger = Logger.get("BleChannel");
+class ReactNativeBleCentralInterface {
+  openChannels = /* @__PURE__ */ new Map();
+  onMatterMessageListener;
+  async openChannel(address) {
+    if (address.type !== "ble") {
+      throw new InternalError(`Unsupported address type ${address.type}.`);
+    }
+    if (this.onMatterMessageListener === void 0) {
+      throw new InternalError(`Network Interface was not added to the system yet.`);
+    }
+    const { peripheral, hasAdditionalAdvertisementData } = Ble.get().getBleScanner().getDiscoveredDevice(address.peripheralAddress);
+    if (this.openChannels.has(address)) {
+      throw new BleError(
+        `Peripheral ${address.peripheralAddress} is already connected. Only one connection supported right now.`
+      );
+    }
+    logger.debug(`Connect to Peripheral now`);
+    let device;
+    try {
+      device = await peripheral.connect();
+    } catch (error) {
+      if (error instanceof ReactNativeBleError && error.errorCode === BleErrorCode.DeviceAlreadyConnected) {
+        device = peripheral;
+      } else {
+        throw new BleError(`Error connecting to peripheral: ${error.message}`);
+      }
+    }
+    logger.debug(`Peripheral connected successfully, MTU = ${device.mtu}`);
+    device = await device.discoverAllServicesAndCharacteristics();
+    const services = await device.services();
+    for (const service of services) {
+      logger.debug(`found service: ${service.uuid}`);
+      if (service.uuid !== BLE_MATTER_SERVICE_UUID) continue;
+      const characteristics = await device.characteristicsForService(service.uuid);
+      let characteristicC1ForWrite;
+      let characteristicC2ForSubscribe;
+      let additionalCommissioningRelatedData;
+      for (const characteristic of characteristics) {
+        logger.debug("found characteristic:", characteristic.uuid);
+        switch (characteristic.uuid) {
+          case BLE_MATTER_C1_CHARACTERISTIC_UUID:
+            logger.debug("found C1 characteristic");
+            characteristicC1ForWrite = characteristic;
+            break;
+          case BLE_MATTER_C2_CHARACTERISTIC_UUID:
+            logger.debug("found C2 characteristic");
+            characteristicC2ForSubscribe = characteristic;
+            break;
+          case BLE_MATTER_C3_CHARACTERISTIC_UUID:
+            logger.debug("found C3 characteristic");
+            if (hasAdditionalAdvertisementData) {
+              logger.debug("reading additional commissioning related data");
+              const characteristicWithValue = await service.readCharacteristic(characteristic.uuid);
+              if (characteristicWithValue.value !== null) {
+                additionalCommissioningRelatedData = Bytes.fromBase64(characteristicWithValue.value);
+              } else {
+                logger.debug("no value in characteristic C3");
+              }
+            }
+        }
+      }
+      if (!characteristicC1ForWrite || !characteristicC2ForSubscribe) {
+        logger.debug("missing characteristics");
+        continue;
+      }
+      this.openChannels.set(address, peripheral);
+      return await ReactNativeBleChannel.create(
+        peripheral,
+        characteristicC1ForWrite,
+        characteristicC2ForSubscribe,
+        this.onMatterMessageListener,
+        additionalCommissioningRelatedData
+      );
+    }
+    throw new BleError(`No Matter service found on peripheral ${peripheral.id}`);
+  }
+  onData(listener) {
+    this.onMatterMessageListener = listener;
+    return {
+      close: async () => await this.close()
+    };
+  }
+  async close() {
+    for (const peripheral of this.openChannels.values()) {
+      await peripheral.cancelConnection();
+    }
+  }
+  supports(type) {
+    return type === ChannelType.BLE;
+  }
+}
+class ReactNativeBleChannel extends BleChannel {
+  constructor(peripheral, btpSession) {
+    super();
+    this.peripheral = peripheral;
+    this.btpSession = btpSession;
+    this.disconnectSubscription = peripheral.onDisconnected((error) => {
+      logger.debug(`Disconnected from peripheral ${peripheral.id}: ${error}`);
+      this.connected = false;
+      this.disconnectSubscription.remove();
+      void this.btpSession.close();
+    });
+  }
+  static async create(peripheral, characteristicC1ForWrite, characteristicC2ForSubscribe, onMatterMessageListener, _additionalCommissioningRelatedData) {
+    let mtu = peripheral.mtu ?? 0;
+    if (mtu > BLE_MAXIMUM_BTP_MTU) {
+      mtu = BLE_MAXIMUM_BTP_MTU;
+    }
+    logger.debug(`Using MTU=${mtu} (Peripheral MTU=${peripheral.mtu})`);
+    const btpHandshakeRequest = BtpCodec.encodeBtpHandshakeRequest({
+      versions: BTP_SUPPORTED_VERSIONS,
+      attMtu: mtu,
+      clientWindowSize: BTP_MAXIMUM_WINDOW_SIZE
+    });
+    logger.debug(`sending BTP handshake request: ${Logger.toJSON(btpHandshakeRequest)}`);
+    characteristicC1ForWrite = await characteristicC1ForWrite.writeWithResponse(
+      Bytes.toBase64(btpHandshakeRequest)
+    );
+    const btpHandshakeTimeout = Time.getTimer("BLE handshake timeout", BTP_CONN_RSP_TIMEOUT_MS, async () => {
+      await peripheral.cancelConnection();
+      logger.debug("Handshake Response not received. Disconnected from peripheral");
+    }).start();
+    logger.debug("subscribing to C2 characteristic");
+    const { promise: handshakeResponseReceivedPromise, resolver } = createPromise();
+    let handshakeReceived = false;
+    const handshakeSubscription = characteristicC2ForSubscribe.monitor((error, characteristic) => {
+      if (error !== null || characteristic === null) {
+        if (error instanceof ReactNativeBleError && error.errorCode === 2 && handshakeReceived) {
+          return;
+        }
+        logger.debug("Error while monitoring C2 characteristic", error);
+        return;
+      }
+      const characteristicData = characteristic.value;
+      if (characteristicData === null) {
+        logger.debug("C2 characteristic value is null");
+        return;
+      }
+      const data = Bytes.fromBase64(characteristicData);
+      logger.debug(`received first data on C2: ${Bytes.toHex(data)}`);
+      if (data[0] === 101 && data[1] === 108 && data.length === 6) {
+        logger.info(`Received Matter handshake response: ${Bytes.toHex(data)}.`);
+        btpHandshakeTimeout.stop();
+        resolver(data);
+      }
+    });
+    const handshakeResponse = await handshakeResponseReceivedPromise;
+    handshakeReceived = true;
+    handshakeSubscription.remove();
+    let connectionCloseExpected = false;
+    const btpSession = await BtpSessionHandler.createAsCentral(
+      new Uint8Array(handshakeResponse),
+      // callback to write data to characteristic C1
+      async (data) => {
+        characteristicC1ForWrite = await characteristicC1ForWrite.writeWithResponse(Bytes.toBase64(data));
+      },
+      // callback to disconnect the BLE connection
+      async () => {
+        connectionCloseExpected = true;
+        dataSubscription.remove();
+        await peripheral.cancelConnection();
+        logger.debug("disconnected from peripheral");
+      },
+      // callback to forward decoded and de-assembled Matter messages to ExchangeManager
+      async (data) => {
+        if (onMatterMessageListener === void 0) {
+          throw new InternalError(`No listener registered for Matter messages`);
+        }
+        onMatterMessageListener(bleChannel, data);
+      }
+    );
+    const dataSubscription = characteristicC2ForSubscribe.monitor((error, characteristic) => {
+      if (error !== null || characteristic === null) {
+        if (error instanceof ReactNativeBleError && error.errorCode === 2 && connectionCloseExpected) {
+          return;
+        }
+        logger.debug("Error while monitoring C2 characteristic", error);
+        return;
+      }
+      const characteristicData = characteristic.value;
+      if (characteristicData === null) {
+        logger.debug("C2 characteristic value is null");
+        return;
+      }
+      const data = Bytes.fromBase64(characteristicData);
+      logger.debug(`received data on C2: ${Bytes.toHex(data)}`);
+      void btpSession.handleIncomingBleData(new Uint8Array(data));
+    });
+    const bleChannel = new ReactNativeBleChannel(peripheral, btpSession);
+    return bleChannel;
+  }
+  connected = true;
+  disconnectSubscription;
+  /**
+   * Send a Matter message to the connected device - need to do BTP assembly first.
+   *
+   * @param data
+   */
+  async send(data) {
+    if (!this.connected) {
+      logger.debug("Cannot send data because not connected to peripheral.");
+      return;
+    }
+    if (this.btpSession === void 0) {
+      throw new BtpFlowError(`Cannot send data, no BTP session initialized`);
+    }
+    await this.btpSession.sendMatterMessage(data);
+  }
+  // Channel<Uint8Array>
+  get name() {
+    return `ble://${this.peripheral.id}`;
+  }
+  async close() {
+    await this.btpSession.close();
+    this.disconnectSubscription.remove();
+    await this.peripheral.cancelConnection();
+  }
+}
+export {
+  ReactNativeBleCentralInterface,
+  ReactNativeBleChannel
+};
+//# sourceMappingURL=ReactNativeBleChannel.js.map