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

package/src/net/NetworkReactNative.ts

@@ -0,0 +1,190 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import dgram from "react-native-udp";
+
+// @ts-expect-error globalThis is no index structure
+global.dgram = dgram;
+
+// @ts-expect-error globalThis is no index structure
+const rnDGramCreateSocket = dgram.createSocket;
+// @ts-expect-error globalThis is no index structure
+// Work around because React-Native UDP lib is not providing the setMulticastInterface method
+dgram.createSocket = (...args: any[]) => {
+    const socket = rnDGramCreateSocket(...args);
+    socket.setMulticastInterface = () => {}; // Stub for now
+
+    const originalSend = socket.send;
+    socket.send = (
+        buffer: Uint8Array,
+        port: number,
+        address: string,
+        callback: (error: Error | null, bytes: number) => void,
+    ) => originalSend(buffer, 0, buffer.length, port, address, callback);
+    return socket;
+};
+
+import {
+    AsyncCache,
+    InterfaceType,
+    isIPv6,
+    Logger,
+    Network,
+    NetworkError,
+    NetworkInterface,
+    NetworkInterfaceDetails,
+    onSameNetwork,
+    UdpChannel,
+    UdpChannelOptions,
+} from "#general";
+import { fetch as fetchNetworkInfo } from "@react-native-community/netinfo";
+import { UdpChannelReactNative } from "./UdpChannelReactNative.js";
+
+const logger = Logger.get("NetworkNode");
+
+type NetworkInterfaceInfo = {
+    address: string;
+    family: string;
+    netmask: string;
+    internal: boolean;
+};
+
+async function networkInterfaces() {
+    const netInfo = [await fetchNetworkInfo("wifi"), await fetchNetworkInfo("ethernet")];
+    const networkInterfaces: Record<string, NetworkInterfaceInfo[]> = {};
+    netInfo.forEach(({ type, isConnected, details }) => {
+        if (!details || !isConnected) return;
+        const ipAddress = "ipAddress" in details ? (details.ipAddress as string | null) : undefined;
+        const subnet = "subnet" in details ? (details.subnet as string | null) : undefined;
+        if (!ipAddress || !subnet) return;
+        networkInterfaces[type] = [
+            {
+                address: ipAddress,
+                family: isIPv6(ipAddress) ? "IPv6" : "IPv4",
+                netmask: subnet,
+                internal: false,
+            },
+        ];
+    });
+    return networkInterfaces;
+}
+
+export class NetworkReactNative extends Network {
+    static async getMulticastInterfaceIpv4(netInterface: string): Promise<string | undefined> {
+        const netInterfaceInfo = (await networkInterfaces())[netInterface];
+        if (netInterfaceInfo === undefined) throw new NetworkError(`Unknown interface: ${netInterface}`);
+        for (const { address, family } of netInterfaceInfo) {
+            if (family === "IPv4") {
+                return address;
+            }
+        }
+        return undefined;
+    }
+
+    static async getMembershipMulticastInterfaces(
+        netInterface: string | undefined,
+        ipv4: boolean,
+    ): Promise<(string | undefined)[]> {
+        if (ipv4) {
+            return [undefined];
+        } else {
+            let networkInterfaceEntries = Object.entries(await networkInterfaces());
+            if (netInterface !== undefined) {
+                networkInterfaceEntries = networkInterfaceEntries.filter(([name]) => name === netInterface);
+            }
+            const multicastInterfaces = networkInterfaceEntries.flatMap(([netInterface, netInterfaceInfo]) => {
+                if (netInterfaceInfo === undefined) return [];
+                const zone = netInterface;
+                return zone === undefined ? [] : [`::%${zone}`];
+            });
+            if (multicastInterfaces.length === 0) {
+                logger.warn(
+                    `No IPv6 multicast interface found${
+                        netInterface !== undefined ? ` for interface ${netInterface}` : ""
+                    }.`,
+                );
+            }
+            return multicastInterfaces;
+        }
+    }
+
+    static getNetInterfaceForIp(ip: string) {
+        // Finding the local interface on the same interface is complex and won't change
+        // So let's cache the results for 5mn
+        return this.netInterfaces.get(ip);
+    }
+
+    private static readonly netInterfaces = new AsyncCache<string | undefined>(
+        "Network interface",
+        (ip: string) => this.getNetInterfaceForRemoveAddress(ip),
+        5 * 60 * 1000 /* 5mn */,
+    );
+
+    override async close() {
+        await NetworkReactNative.netInterfaces.close();
+    }
+
+    private static async getNetInterfaceForRemoveAddress(ip: string) {
+        if (ip.includes("%")) {
+            // IPv6 address with scope
+            return ip.split("%")[1];
+        } else {
+            const interfaces = await networkInterfaces();
+            for (const name in interfaces) {
+                const netInterfaces = interfaces[name];
+                for (const { address, netmask } of netInterfaces) {
+                    if (onSameNetwork(ip, address, netmask)) {
+                        return name;
+                    }
+                }
+            }
+            if (isIPv6(ip)) {
+                if (ip.startsWith("fd")) {
+                    // IPv6 address is an ULA
+                    return ""; // consider it as being ok and using the "Default interface"
+                }
+            }
+            return undefined;
+        }
+    }
+
+    /**
+     * Get all network interfaces.
+     * The optional configuration parameter allows to map interface names to types if this mapping is known.
+     * Each network interface which has no mapped type is returned as Ethernet for now.
+     *
+     * @param configuration - An array of objects with the name and type properties.
+     */
+    async getNetInterfaces(configuration: NetworkInterface[] = []): Promise<NetworkInterface[]> {
+        const result = new Array<NetworkInterface>();
+        const interfaces = await networkInterfaces();
+        for (const name in interfaces) {
+            const netInterfaces = interfaces[name];
+            if (netInterfaces.length === 0) continue;
+            if (netInterfaces[0].internal) continue;
+            let type = InterfaceType.Ethernet;
+            if (configuration.length > 0) {
+                const nameType = configuration.find(({ name: mapName }) => name === mapName);
+                if (nameType !== undefined && nameType.type !== undefined) {
+                    type = nameType.type;
+                }
+            }
+            result.push({ name, type });
+        }
+        return result;
+    }
+
+    async getIpMac(netInterface: string): Promise<NetworkInterfaceDetails | undefined> {
+        const netInterfaceInfo = (await networkInterfaces())[netInterface];
+        if (netInterfaceInfo === undefined) return undefined;
+        const ipV4 = netInterfaceInfo.filter(({ family }) => family === "IPv4").map(({ address }) => address);
+        const ipV6 = netInterfaceInfo.filter(({ family }) => family === "IPv6").map(({ address }) => address);
+        return { mac: "00:00:00:00:00:00", ipV4, ipV6 };
+    }
+
+    override createUdpChannel(options: UdpChannelOptions): Promise<UdpChannel> {
+        return UdpChannelReactNative.create(options);
+    }
+}

package/src/net/UdpChannelReactNative.ts

@@ -0,0 +1,219 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import dgram from "react-native-udp";
+
+import {
+    ChannelType,
+    Diagnostic,
+    isIPv4,
+    isIPv6,
+    Logger,
+    MAX_UDP_MESSAGE_SIZE,
+    NetworkError,
+    UdpChannel,
+    UdpChannelOptions,
+} from "#general";
+import { NetworkReactNative } from "./NetworkReactNative.js";
+
+const logger = Logger.get("UdpChannelNode");
+
+// Move out some dram types not available in react-native-udp
+// TODO find a way to clean that up once anything is working
+interface RemoteInfo {
+    address: string;
+    family: "IPv4" | "IPv6";
+    port: number;
+    size: number;
+}
+type SocketType = "udp4" | "udp6";
+interface SocketOptions {
+    type: SocketType;
+    reuseAddr?: boolean | undefined;
+    /**
+     * @default false
+     */
+    ipv6Only?: boolean | undefined;
+    recvBufferSize?: number | undefined;
+    sendBufferSize?: number | undefined;
+    lookup?:
+        | ((
+              hostname: string,
+              options: any,
+              callback: (err: Error | null, address: string, family: number) => void,
+          ) => void)
+        | undefined;
+}
+interface Socket {
+    setBroadcast(flag: boolean): void;
+    setMulticastInterface(interfaceAddress: string): void;
+    addMembership(multicastAddress: string, multicastInterface?: string): void;
+    on(event: "message", listener: (msg: Uint8Array, rinfo: RemoteInfo) => void): void;
+    on(event: "error", listener: (error: Error) => void): void;
+    removeListener(event: "message", listener: (msg: Uint8Array, rinfo: RemoteInfo) => void): void;
+    removeListener(event: "error", listener: (error: Error) => void): void;
+    send(msg: Uint8Array, port: number, address: string, callback: (error: Error | null) => void): void;
+    close(): void;
+    address(): { address: string; port: number };
+}
+
+function createDgramSocket(host: string | undefined, port: number | undefined, options: SocketOptions) {
+    // @ts-expect-error default types are strange
+    const socket = dgram.createSocket({
+        ...options,
+        reusePort: options.reuseAddr,
+    });
+    return new Promise<Socket>((resolve, reject) => {
+        const handleBindError = (error: Error) => {
+            try {
+                socket.close();
+            } catch (error) {
+                logger.debug("Error on closing socket", error);
+            }
+            reject(error);
+        };
+        socket.on("error", handleBindError);
+        socket.bind(port, host, (error: any) => {
+            if (error) return;
+            const { address: localHost, port: localPort } = socket.address();
+            logger.debug(
+                "Socket created and bound ",
+                Diagnostic.dict({
+                    remoteAddress: `${host}:${port}`,
+                    localAddress: `${localHost}:${localPort}`,
+                }),
+            );
+            socket.removeListener("error", handleBindError);
+            socket.on("error", (error: Error) => logger.error(error));
+            resolve(socket);
+        });
+    });
+}
+
+export class UdpChannelReactNative implements UdpChannel {
+    static async create({
+        listeningPort,
+        type,
+        listeningAddress,
+        netInterface,
+        membershipAddresses,
+    }: UdpChannelOptions) {
+        const socketOptions: SocketOptions = { type, reuseAddr: true };
+        if (type === "udp6") {
+            socketOptions.ipv6Only = true;
+        }
+        const socket = await createDgramSocket(listeningAddress, listeningPort, socketOptions);
+        socket.setBroadcast(true);
+        let netInterfaceZone: string | undefined;
+        if (netInterface !== undefined) {
+            netInterfaceZone = netInterface;
+            let multicastInterface: string | undefined;
+            if (type === "udp4") {
+                multicastInterface = await NetworkReactNative.getMulticastInterfaceIpv4(netInterface);
+                if (multicastInterface === undefined) {
+                    throw new NetworkError(`No IPv4 addresses on interface: ${netInterface}`);
+                }
+            } else {
+                multicastInterface = `::%${netInterfaceZone}`;
+            }
+            logger.debug(
+                "Initialize multicast",
+                Diagnostic.dict({
+                    address: `${multicastInterface}:${listeningPort}`,
+                    interface: netInterface,
+                    type: type,
+                }),
+            );
+            socket.setMulticastInterface(multicastInterface);
+        }
+        if (membershipAddresses !== undefined) {
+            const multicastInterfaces = await NetworkReactNative.getMembershipMulticastInterfaces(
+                netInterface,
+                type === "udp4",
+            );
+            for (const address of membershipAddresses) {
+                for (const multicastInterface of multicastInterfaces) {
+                    try {
+                        socket.addMembership(address, multicastInterface);
+                    } catch (error) {
+                        logger.warn(
+                            `Error adding membership for address ${address}${
+                                multicastInterface ? ` with interface ${multicastInterface}` : ""
+                            }: ${error}`,
+                        );
+                    }
+                }
+            }
+        }
+        return new UdpChannelReactNative(type, socket, netInterfaceZone);
+    }
+
+    readonly maxPayloadSize = MAX_UDP_MESSAGE_SIZE;
+
+    constructor(
+        private readonly type: "udp4" | "udp6",
+        private readonly socket: Socket,
+        private readonly netInterface?: string,
+    ) {}
+
+    onData(listener: (netInterface: string, peerAddress: string, peerPort: number, data: Uint8Array) => void) {
+        const messageListener = async (data: Uint8Array, { address, port }: RemoteInfo) => {
+            const netInterface = this.netInterface ?? (await NetworkReactNative.getNetInterfaceForIp(address));
+            if (netInterface === undefined) return;
+            listener(netInterface, address, port, data);
+        };
+
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        this.socket.on("message", messageListener);
+        return {
+            close: async () => {
+                // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                this.socket.removeListener("message", messageListener);
+            },
+        };
+    }
+
+    async send(host: string, port: number, data: Uint8Array) {
+        return new Promise<void>((resolve, reject) => {
+            this.socket.send(data, port, host, error => {
+                if (error !== null) {
+                    const netError = new NetworkError(error.message);
+                    netError.stack = error.stack;
+                    reject(netError);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+
+    async close() {
+        try {
+            this.socket.close();
+        } catch (error) {
+            logger.debug("Error on closing socket", error);
+        }
+    }
+
+    get port() {
+        return this.socket.address().port;
+    }
+
+    supports(type: ChannelType, address?: string) {
+        if (type !== ChannelType.UDP) {
+            return false;
+        }
+
+        if (address === undefined) {
+            return true;
+        }
+
+        if (this.type === "udp4") {
+            return isIPv4(address);
+        }
+
+        return isIPv6(address);
+    }
+}

package/src/net/export.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Network } from "@matter/general";
+
+export * from "./NetworkReactNative.js";
+
+export async function closeNetwork() {
+    return Network.get().close();
+}

package/src/net/register.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Network, NoProviderError, singleton } from "@matter/general";
+import { NetworkReactNative } from "./NetworkReactNative.js";
+
+// Check if Network singleton is already registered and auto register if not
+try {
+    Network.get();
+} catch (error) {
+    NoProviderError.accept(error);
+    Network.get = singleton(() => new NetworkReactNative());
+    // use net export closeNetwork() to close the network
+}

package/src/storage/StorageBackendAsyncStorage.ts

@@ -0,0 +1,145 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { MaybeAsyncStorage, StorageError, SupportedStorageTypes, fromJson, toJson } from "#general";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+
+export class StorageBackendAsyncStorage extends MaybeAsyncStorage {
+    #namespace: string;
+    protected isInitialized = false;
+
+    /**
+     * Creates a new instance of the AsyncStorage storage backend. In a "namespace" is provided then the keys will be
+     * prefixed with the namespace (separated with a # which is normally not used in matter.js keys).
+     */
+    constructor(namespace?: string) {
+        super();
+        this.#namespace = namespace ?? "";
+    }
+
+    get initialized() {
+        return this.isInitialized;
+    }
+
+    initialize() {
+        this.isInitialized = true;
+    }
+
+    close() {
+        this.isInitialized = false;
+    }
+
+    clear() {
+        // @ts-expect-error AsyncStorage types are not correct
+        return AsyncStorage.clear();
+    }
+
+    getContextBaseKey(contexts: string[], allowEmptyContext = false) {
+        const contextKey = contexts.join(".");
+        if (
+            (!contextKey.length && !allowEmptyContext) ||
+            contextKey.includes("..") ||
+            contextKey.startsWith(".") ||
+            contextKey.endsWith(".")
+        )
+            throw new StorageError("Context must not be an empty and not contain dots.");
+        return `${this.#namespace.length ? `${this.#namespace}#` : ""}${contextKey}`;
+    }
+
+    buildStorageKey(contexts: string[], key: string) {
+        if (!key.length) {
+            throw new StorageError("Key must not be an empty string.");
+        }
+        const contextKey = this.getContextBaseKey(contexts);
+        return `${contextKey}.${key}`;
+    }
+
+    async get<T extends SupportedStorageTypes>(contexts: string[], key: string): Promise<T | undefined> {
+        // @ts-expect-error AsyncStorage types are not correct
+        const value = await AsyncStorage.getItem(this.buildStorageKey(contexts, key));
+        if (value === null) return undefined;
+        return fromJson(value) as T;
+    }
+
+    set(contexts: string[], key: string, value: SupportedStorageTypes): Promise<void>;
+    set(contexts: string[], values: Record<string, SupportedStorageTypes>): Promise<void>;
+    async set(
+        contexts: string[],
+        keyOrValues: string | Record<string, SupportedStorageTypes>,
+        value?: SupportedStorageTypes,
+    ) {
+        if (typeof keyOrValues === "string") {
+            // @ts-expect-error AsyncStorage types are not correct
+            await AsyncStorage.setItem(this.buildStorageKey(contexts, keyOrValues), toJson(value));
+        } else {
+            for (const [key, value] of Object.entries(keyOrValues)) {
+                // @ts-expect-error AsyncStorage types are not correct
+                await AsyncStorage.setItem(this.buildStorageKey(contexts, key), toJson(value));
+            }
+        }
+    }
+
+    delete(contexts: string[], key: string) {
+        // @ts-expect-error AsyncStorage types are not correct
+        return AsyncStorage.removeItem(this.buildStorageKey(contexts, key));
+    }
+
+    /** Returns all keys of a storage context without keys of sub-contexts */
+    async keys(contexts: string[]) {
+        const contextKey = this.getContextBaseKey(contexts);
+        const keys = [];
+        const contextKeyStart = `${contextKey}.`;
+        // @ts-expect-error AsyncStorage types are not correct
+        const allKeys = await AsyncStorage.getAllKeys();
+        for (const key of allKeys) {
+            if (key.startsWith(contextKeyStart) && !key.includes(".", contextKeyStart.length)) {
+                keys.push(key.substring(contextKeyStart.length));
+            }
+        }
+        return keys;
+    }
+
+    async values(contexts: string[]) {
+        // Initialize and context checks are done by keys method
+        const values = {} as Record<string, SupportedStorageTypes>;
+        for (const key of await this.keys(contexts)) {
+            values[key] = await this.get(contexts, key);
+        }
+        return values;
+    }
+
+    async contexts(contexts: string[]) {
+        const contextKey = this.getContextBaseKey(contexts, true);
+        const startContextKey = contextKey.length ? `${contextKey}.` : "";
+        const foundContexts = new Array<string>();
+        // @ts-expect-error AsyncStorage types are not correct
+        const allKeys = await AsyncStorage.getAllKeys();
+        for (const key of allKeys) {
+            if (key.startsWith(startContextKey)) {
+                const subKeys = key.substring(startContextKey.length).split(".");
+                if (subKeys.length === 1) continue; // found leaf key
+                const context = subKeys[0];
+                if (!foundContexts.includes(context)) {
+                    foundContexts.push(context);
+                }
+            }
+        }
+        return foundContexts;
+    }
+
+    async clearAll(contexts: string[]) {
+        const contextKey = this.getContextBaseKey(contexts, true);
+        const startContextKey = contextKey.length ? `${contextKey}.` : "";
+        // @ts-expect-error AsyncStorage types are not correct
+        const allKeys = await AsyncStorage.getAllKeys();
+        for (const key of allKeys) {
+            if (key.startsWith(startContextKey)) {
+                // @ts-expect-error AsyncStorage types are not correct
+                await AsyncStorage.removeItem(key);
+            }
+        }
+    }
+}

package/src/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "extends": "../../tools/tsc/tsconfig.lib.json",
+    "compilerOptions": {
+        "types": []
+    },
+    "references": [
+        {
+            "path": "../../nodejs/src"
+        },
+        {
+            "path": "../../general/src"
+        },
+        {
+            "path": "../../protocol/src"
+        }
+    ]
+}