react-native-ble-mesh 1.0.1

package/src/hooks/AppStateManager.js

@@ -0,0 +1,179 @@
+'use strict';
+
+/**
+ * @fileoverview React Native app state management for mesh service
+ * @module hooks/AppStateManager
+ */
+
+/**
+ * Manages React Native app state transitions for mesh service.
+ * Automatically handles background/foreground power mode switching.
+ *
+ * @class AppStateManager
+ *
+ * @example
+ * const mesh = new MeshService();
+ * const appStateManager = new AppStateManager(mesh);
+ * appStateManager.initialize();
+ *
+ * // On component unmount:
+ * appStateManager.destroy();
+ */
+class AppStateManager {
+  /**
+   * Creates a new AppStateManager
+   * @param {MeshService} mesh - MeshService instance to manage
+   * @param {Object} [options] - Configuration options
+   * @param {string} [options.backgroundMode='ULTRA_POWER_SAVER'] - Power mode for background
+   * @param {string} [options.foregroundMode='BALANCED'] - Power mode for foreground
+   * @param {boolean} [options.autoSaveState=true] - Auto save state on background
+   */
+  constructor(mesh, options = {}) {
+    /** @private */
+    this._mesh = mesh;
+    /** @private */
+    this._options = {
+      backgroundMode: options.backgroundMode || 'ULTRA_POWER_SAVER',
+      foregroundMode: options.foregroundMode || 'BALANCED',
+      autoSaveState: options.autoSaveState !== false
+    };
+    /** @private */
+    this._appState = 'active';
+    /** @private */
+    this._subscription = null;
+    /** @private */
+    this._initialized = false;
+    /** @private */
+    this._AppState = null;
+  }
+
+  /**
+   * Initialize app state monitoring
+   * @returns {boolean} True if initialized, false if AppState not available
+   */
+  initialize() {
+    if (this._initialized) { return true; }
+
+    // Try to get AppState from React Native
+    try {
+      const { AppState } = require('react-native');
+      this._AppState = AppState;
+    } catch (e) {
+      // React Native not available (Node.js environment)
+      console.warn('AppStateManager: React Native AppState not available');
+      return false;
+    }
+
+    this._subscription = this._AppState.addEventListener(
+      'change',
+      this._handleStateChange.bind(this)
+    );
+
+    this._initialized = true;
+    return true;
+  }
+
+  /**
+   * Handle app state change
+   * @private
+   * @param {string} nextAppState - New app state
+   */
+  _handleStateChange(nextAppState) {
+    const wasActive = this._appState === 'active';
+    const isActive = nextAppState === 'active';
+
+    // Going to background
+    if (wasActive && !isActive) {
+      this._onBackground();
+    }
+
+    // Coming to foreground
+    if (!wasActive && isActive) {
+      this._onForeground();
+    }
+
+    this._appState = nextAppState;
+  }
+
+  /**
+   * Called when app goes to background
+   * @private
+   */
+  _onBackground() {
+    if (!this._mesh) { return; }
+
+    try {
+      // Switch to power saver mode
+      if (typeof this._mesh.setPowerMode === 'function') {
+        this._mesh.setPowerMode(this._options.backgroundMode);
+      }
+
+      // Save state if enabled
+      if (this._options.autoSaveState && typeof this._mesh._saveState === 'function') {
+        this._mesh._saveState();
+      }
+    } catch (e) {
+      console.warn('AppStateManager: Error handling background transition', e);
+    }
+  }
+
+  /**
+   * Called when app comes to foreground
+   * @private
+   */
+  _onForeground() {
+    if (!this._mesh) { return; }
+
+    try {
+      // Restore normal power mode
+      if (typeof this._mesh.setPowerMode === 'function') {
+        this._mesh.setPowerMode(this._options.foregroundMode);
+      }
+
+      // Restore state if enabled
+      if (this._options.autoSaveState && typeof this._mesh._restoreState === 'function') {
+        this._mesh._restoreState();
+      }
+    } catch (e) {
+      console.warn('AppStateManager: Error handling foreground transition', e);
+    }
+  }
+
+  /**
+   * Get current app state
+   * @returns {string} Current app state ('active', 'background', 'inactive')
+   */
+  getAppState() {
+    return this._appState;
+  }
+
+  /**
+   * Check if app is in foreground
+   * @returns {boolean} True if app is active
+   */
+  isActive() {
+    return this._appState === 'active';
+  }
+
+  /**
+   * Check if app is in background
+   * @returns {boolean} True if app is in background
+   */
+  isBackground() {
+    return this._appState === 'background';
+  }
+
+  /**
+   * Destroy the manager and cleanup subscriptions
+   */
+  destroy() {
+    if (this._subscription) {
+      this._subscription.remove();
+      this._subscription = null;
+    }
+    this._mesh = null;
+    this._initialized = false;
+  }
+}
+
+module.exports = AppStateManager;

package/src/hooks/index.js

@@ -0,0 +1,33 @@
+'use strict';
+
+/**
+ * @fileoverview React Native hooks for BLE Mesh
+ * @module hooks
+ *
+ * @description
+ * React Native hooks for easy integration with BLE Mesh.
+ * These hooks handle lifecycle management, state updates, and cleanup.
+ *
+ * @example
+ * import { useMesh, usePeers, useMessages } from 'react-native-ble-mesh/hooks';
+ *
+ * function App() {
+ *   const { mesh, state, initialize } = useMesh({ displayName: 'MyDevice' });
+ *   const { peers, connectedPeers } = usePeers(mesh);
+ *   const { messages, sendBroadcast } = useMessages(mesh);
+ *
+ *   // ... your app logic
+ * }
+ */
+
+const useMesh = require('./useMesh');
+const usePeers = require('./usePeers');
+const useMessages = require('./useMessages');
+const AppStateManager = require('./AppStateManager');
+
+module.exports = {
+  useMesh,
+  usePeers,
+  useMessages,
+  AppStateManager
+};

package/src/hooks/useMesh.js

@@ -0,0 +1,159 @@
+'use strict';
+
+/**
+ * @fileoverview React hook for MeshService
+ * @module hooks/useMesh
+ */
+
+/**
+ * React hook for managing MeshService lifecycle in React Native apps.
+ * Handles initialization, cleanup, and state management.
+ *
+ * @param {Object} [config] - MeshService configuration
+ * @param {string} [config.displayName] - Display name for this node
+ * @param {Object} [config.storage] - Storage adapter
+ * @returns {Object} Mesh state and controls
+ *
+ * @example
+ * function App() {
+ *   const { mesh, state, error, initialize, destroy } = useMesh({
+ *     displayName: 'MyDevice'
+ *   });
+ *
+ *   useEffect(() => {
+ *     initialize();
+ *     return () => destroy();
+ *   }, []);
+ *
+ *   if (state === 'error') return <Text>Error: {error.message}</Text>;
+ *   if (state !== 'active') return <Text>Loading...</Text>;
+ *
+ *   return <ChatScreen mesh={mesh} />;
+ * }
+ */
+function useMesh(config = {}) {
+  // This hook requires React - check if available
+  let React;
+  try {
+    React = require('react');
+  } catch (e) {
+    throw new Error('useMesh requires React. Install react as a dependency.');
+  }
+
+  const { useState, useCallback, useRef, useEffect } = React;
+  const { MeshService } = require('../service');
+  const { MemoryStorage } = require('../storage');
+
+  // Create mesh instance ref (persists across renders)
+  const meshRef = useRef(null);
+
+  // State
+  const [state, setState] = useState('uninitialized');
+  const [error, setError] = useState(null);
+
+  // Create mesh instance lazily
+  const getMesh = useCallback(() => {
+    if (!meshRef.current) {
+      meshRef.current = new MeshService({
+        displayName: config.displayName || 'MeshNode'
+      });
+    }
+    return meshRef.current;
+  }, [config.displayName]);
+
+  // Initialize mesh
+  const initialize = useCallback(async (transport) => {
+    try {
+      setState('initializing');
+      setError(null);
+
+      const mesh = getMesh();
+
+      // Setup state change listener
+      mesh.on('state-changed', ({ newState }) => {
+        setState(newState);
+      });
+
+      mesh.on('error', (err) => {
+        setError(err);
+      });
+
+      // Initialize with storage
+      await mesh.initialize({
+        storage: config.storage || new MemoryStorage()
+      });
+
+      // Start with transport if provided
+      if (transport) {
+        await mesh.start(transport);
+      }
+
+      return mesh;
+    } catch (err) {
+      setState('error');
+      setError(err);
+      throw err;
+    }
+  }, [getMesh, config.storage]);
+
+  // Start with transport
+  const start = useCallback(async (transport) => {
+    const mesh = getMesh();
+    try {
+      await mesh.start(transport);
+    } catch (err) {
+      setError(err);
+      throw err;
+    }
+  }, [getMesh]);
+
+  // Stop mesh
+  const stop = useCallback(async () => {
+    const mesh = meshRef.current;
+    if (mesh) {
+      try {
+        await mesh.stop();
+      } catch (err) {
+        setError(err);
+      }
+    }
+  }, []);
+
+  // Destroy mesh
+  const destroy = useCallback(async () => {
+    const mesh = meshRef.current;
+    if (mesh) {
+      try {
+        await mesh.destroy();
+      } catch (err) {
+        // Ignore destroy errors
+      }
+      meshRef.current = null;
+      setState('destroyed');
+    }
+  }, []);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      if (meshRef.current) {
+        meshRef.current.destroy().catch(() => {});
+        meshRef.current = null;
+      }
+    };
+  }, []);
+
+  return {
+    mesh: meshRef.current,
+    state,
+    error,
+    initialize,
+    start,
+    stop,
+    destroy,
+    isReady: state === 'ready' || state === 'active',
+    isActive: state === 'active'
+  };
+}
+
+module.exports = useMesh;

package/src/hooks/useMessages.js

@@ -0,0 +1,209 @@
+'use strict';
+
+/**
+ * @fileoverview React hook for message handling
+ * @module hooks/useMessages
+ */
+
+/**
+ * React hook for sending and receiving messages in the mesh network.
+ * Manages message state and provides send functions.
+ *
+ * @param {MeshService} mesh - MeshService instance
+ * @param {Object} [options] - Options
+ * @param {number} [options.maxMessages=100] - Maximum messages to keep in state
+ * @returns {Object} Messages state and send functions
+ *
+ * @example
+ * function Chat({ mesh, peerId }) {
+ *   const { messages, sendPrivate, sendBroadcast } = useMessages(mesh);
+ *
+ *   const handleSend = async (text) => {
+ *     if (peerId) {
+ *       await sendPrivate(peerId, text);
+ *     } else {
+ *       sendBroadcast(text);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       {messages.map(msg => <Message key={msg.id} data={msg} />)}
+ *       <Input onSubmit={handleSend} />
+ *     </View>
+ *   );
+ * }
+ */
+function useMessages(mesh, options = {}) {
+  // This hook requires React
+  let React;
+  try {
+    React = require('react');
+  } catch (e) {
+    throw new Error('useMessages requires React. Install react as a dependency.');
+  }
+
+  const { useState, useEffect, useCallback, useRef } = React;
+
+  const maxMessages = options.maxMessages || 100;
+  const [messages, setMessages] = useState([]);
+  const [sending, setSending] = useState(false);
+  const [error, setError] = useState(null);
+  const messageIdRef = useRef(new Set());
+
+  // Add message to state (with dedup)
+  const addMessage = useCallback((msg) => {
+    if (messageIdRef.current.has(msg.id)) { return; }
+    messageIdRef.current.add(msg.id);
+
+    setMessages(prev => {
+      const updated = [msg, ...prev];
+      // Trim to max messages
+      if (updated.length > maxMessages) {
+        const removed = updated.slice(maxMessages);
+        removed.forEach(m => messageIdRef.current.delete(m.id));
+        return updated.slice(0, maxMessages);
+      }
+      return updated;
+    });
+  }, [maxMessages]);
+
+  // Subscribe to message events
+  useEffect(() => {
+    if (!mesh) { return; }
+
+    const handleBroadcast = (data) => {
+      addMessage({
+        id: data.messageId,
+        type: 'broadcast',
+        content: data.content,
+        senderId: data.peerId,
+        timestamp: data.timestamp || Date.now(),
+        isOwn: false
+      });
+    };
+
+    const handlePrivate = (data) => {
+      addMessage({
+        id: data.messageId,
+        type: 'private',
+        content: data.content,
+        senderId: data.peerId,
+        timestamp: data.timestamp || Date.now(),
+        isOwn: false
+      });
+    };
+
+    const handleChannel = (data) => {
+      addMessage({
+        id: data.messageId,
+        type: 'channel',
+        content: data.content,
+        senderId: data.peerId,
+        channelId: data.channelId,
+        timestamp: data.timestamp || Date.now(),
+        isOwn: false
+      });
+    };
+
+    mesh.on('broadcast-received', handleBroadcast);
+    mesh.on('private-message-received', handlePrivate);
+    mesh.on('channel-message-received', handleChannel);
+
+    return () => {
+      mesh.off('broadcast-received', handleBroadcast);
+      mesh.off('private-message-received', handlePrivate);
+      mesh.off('channel-message-received', handleChannel);
+    };
+  }, [mesh, addMessage]);
+
+  // Send broadcast message
+  const sendBroadcast = useCallback((content) => {
+    if (!mesh) { throw new Error('Mesh not initialized'); }
+    setError(null);
+
+    try {
+      const messageId = mesh.sendBroadcast(content);
+      addMessage({
+        id: messageId,
+        type: 'broadcast',
+        content,
+        senderId: mesh.getIdentity()?.id,
+        timestamp: Date.now(),
+        isOwn: true
+      });
+      return messageId;
+    } catch (err) {
+      setError(err);
+      throw err;
+    }
+  }, [mesh, addMessage]);
+
+  // Send private message
+  const sendPrivate = useCallback(async (peerId, content) => {
+    if (!mesh) { throw new Error('Mesh not initialized'); }
+    setError(null);
+    setSending(true);
+
+    try {
+      const messageId = await mesh.sendPrivateMessage(peerId, content);
+      addMessage({
+        id: messageId,
+        type: 'private',
+        content,
+        recipientId: peerId,
+        senderId: mesh.getIdentity()?.id,
+        timestamp: Date.now(),
+        isOwn: true
+      });
+      return messageId;
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setSending(false);
+    }
+  }, [mesh, addMessage]);
+
+  // Send channel message
+  const sendToChannel = useCallback((channelId, content) => {
+    if (!mesh) { throw new Error('Mesh not initialized'); }
+    setError(null);
+
+    try {
+      const messageId = mesh.sendChannelMessage(channelId, content);
+      addMessage({
+        id: messageId,
+        type: 'channel',
+        content,
+        channelId,
+        senderId: mesh.getIdentity()?.id,
+        timestamp: Date.now(),
+        isOwn: true
+      });
+      return messageId;
+    } catch (err) {
+      setError(err);
+      throw err;
+    }
+  }, [mesh, addMessage]);
+
+  // Clear messages
+  const clearMessages = useCallback(() => {
+    setMessages([]);
+    messageIdRef.current.clear();
+  }, []);
+
+  return {
+    messages,
+    sending,
+    error,
+    sendBroadcast,
+    sendPrivate,
+    sendToChannel,
+    clearMessages,
+    messageCount: messages.length
+  };
+}
+
+module.exports = useMessages;

package/src/hooks/usePeers.js

@@ -0,0 +1,111 @@
+'use strict';
+
+/**
+ * @fileoverview React hook for peer management
+ * @module hooks/usePeers
+ */
+
+/**
+ * React hook for managing and observing peers in the mesh network.
+ * Automatically updates when peers connect, disconnect, or change state.
+ *
+ * @param {MeshService} mesh - MeshService instance
+ * @returns {Object} Peers state and utilities
+ *
+ * @example
+ * function PeerList({ mesh }) {
+ *   const { peers, connectedPeers, getPeer } = usePeers(mesh);
+ *
+ *   return (
+ *     <View>
+ *       <Text>Connected: {connectedPeers.length}</Text>
+ *       {peers.map(peer => (
+ *         <PeerItem key={peer.id} peer={peer} />
+ *       ))}
+ *     </View>
+ *   );
+ * }
+ */
+function usePeers(mesh) {
+  // This hook requires React
+  let React;
+  try {
+    React = require('react');
+  } catch (e) {
+    throw new Error('usePeers requires React. Install react as a dependency.');
+  }
+
+  const { useState, useEffect, useCallback, useMemo } = React;
+
+  const [peers, setPeers] = useState([]);
+  const [lastUpdate, setLastUpdate] = useState(Date.now());
+
+  // Update peers from mesh
+  const refreshPeers = useCallback(() => {
+    if (mesh) {
+      try {
+        const allPeers = mesh.getPeers();
+        setPeers(allPeers);
+        setLastUpdate(Date.now());
+      } catch (e) {
+        // Mesh might not be ready
+      }
+    }
+  }, [mesh]);
+
+  // Subscribe to peer events
+  useEffect(() => {
+    if (!mesh) { return; }
+
+    const handlePeerEvent = () => refreshPeers();
+
+    mesh.on('peer-discovered', handlePeerEvent);
+    mesh.on('peer-connected', handlePeerEvent);
+    mesh.on('peer-disconnected', handlePeerEvent);
+    mesh.on('peer-secured', handlePeerEvent);
+
+    // Initial load
+    refreshPeers();
+
+    return () => {
+      mesh.off('peer-discovered', handlePeerEvent);
+      mesh.off('peer-connected', handlePeerEvent);
+      mesh.off('peer-disconnected', handlePeerEvent);
+      mesh.off('peer-secured', handlePeerEvent);
+    };
+  }, [mesh, refreshPeers]);
+
+  // Computed values
+  const connectedPeers = useMemo(() => {
+    return peers.filter(p => p.connectionState === 'connected' || p.connectionState === 'secured');
+  }, [peers]);
+
+  const securedPeers = useMemo(() => {
+    return peers.filter(p => p.connectionState === 'secured');
+  }, [peers]);
+
+  // Get single peer by ID
+  const getPeer = useCallback((peerId) => {
+    return peers.find(p => p.id === peerId);
+  }, [peers]);
+
+  // Check if peer is connected
+  const isConnected = useCallback((peerId) => {
+    const peer = getPeer(peerId);
+    return peer && (peer.connectionState === 'connected' || peer.connectionState === 'secured');
+  }, [getPeer]);
+
+  return {
+    peers,
+    connectedPeers,
+    securedPeers,
+    peerCount: peers.length,
+    connectedCount: connectedPeers.length,
+    getPeer,
+    isConnected,
+    refresh: refreshPeers,
+    lastUpdate
+  };
+}
+
+module.exports = usePeers;