react-native-esp-prov-toolkit/lib/module/hooks/useProvisionDevice.js

A prov toolkit for esp

"use strict";

import { PTSecurity, PTTransport, PTSessionStatus, PTProvisionStatus, createESPDevice, connectToESPDevice, disconnectFromESPDevice, isESPDeviceSessionEstablished, scanWifiListOfESPDevice, provisionESPDevice, PTError } from 'react-native-esp-prov-toolkit';
import { PTException } from "../utils.js";
import { useCallback } from 'react';

/**
 * A custom hook that provides device provisioning functionality for ESP devices.
 * This hook returns a set of functions that can be used to manage device connections,
 * scan for WiFi networks, and provision devices.
 * @param PTSecurity The security level for device provisioning
 * @param PTTransport The transport method for device communication
 * @returns Object An object containing provisioning functions
 */
export function useProvisionDevice(security = PTSecurity.SECURITY_0, transport = PTTransport.TRANSPORT_SOFTAP) {
  const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

  /**
   * Connects to an ESP device with the specified parameters.
   * @param deviceName - The name of the device to connect to
   * @param softAPPassword - Optional SoftAP password if using SoftAP transport
   * @param username - Optional username for secure connections
   * @param proofOfPossession - Optional proof of possession for secure connections
   * @returns Promise  The session status after connection attempt
   * @throws Error If the connection fails
   */
  const connect = useCallback(async (deviceName, softAPPassword, username, proofOfPossession) => {
    // First create the device if it doesn't exist
    await createESPDevice(deviceName, transport, security, proofOfPossession, softAPPassword, username);
    const result = await connectToESPDevice(deviceName);
    // if we are going to need check manually, lets handle it here
    if (result === PTSessionStatus.CHECK_MANUALLY) {
      // sleep for 3 seconds to let it settle
      await sleep(3000);
      // Poll for session establishment 5 times with 1 second intervals
      for (let i = 0; i < 5; i++) {
        if (isESPDeviceSessionEstablished(deviceName)) {
          return 'connected';
        }
        await sleep(1000);
      }
      // if we still have nothing, raise sofAP error
      throw new PTException(PTError.SOFTAP_CONNECTION_FAILURE);
    } else if (result === PTSessionStatus.CONNECTED) {
      return 'connected';
    }
    // else
    return 'disconnected';
  }, [security, transport]);

  /**
   * Disconnects from an ESP device.
   * @param deviceName  The name of the device to disconnect from
   * @throws If the disconnection fails
   */
  const disconnect = useCallback(deviceName => {
    disconnectFromESPDevice(deviceName);
  }, []);

  /**
   * Checks if a session is established with the specified device.
   * @param deviceName - The name of the device to check
   * @returns boolean True if a session is established, false otherwise
   * @throws If the check fails
   */
  const isConnected = useCallback(deviceName => {
    return isESPDeviceSessionEstablished(deviceName);
  }, []);

  /**
   * Fetches the list of available WiFi networks from the ESP device.
   * @param deviceName - The name of the device to scan from
   * @returns Promise<PTWifiEntry[]> List of available WiFi networks
   * @throws If the scan fails
   */
  const fetchWifiList = useCallback(async deviceName => {
    return await scanWifiListOfESPDevice(deviceName);
  }, []);

  /**
   * Provisions an ESP device with WiFi credentials.
   * @param deviceName - The name of the device to provision
   * @param ssid - The SSID of the WiFi network to connect to
   * @param password - The password of the WiFi network
   * @returns Promise<PTProvisionStatus> The provisioning status
   * @throws If the provisioning fails
   */
  const provision = useCallback(async (deviceName, ssid, password) => {
    const result = await provisionESPDevice(deviceName, ssid, password);
    if (result === PTProvisionStatus.CONFIG_APPLIED) {
      return 'config-applied';
    }
    return 'success';
  }, []);
  return {
    connect,
    disconnect,
    isConnected,
    fetchWifiList,
    provision
  };
}
//# sourceMappingURL=useProvisionDevice.js.map