react-native-flic2 2.0.0-alpha.39 → 2.0.0-beta.1

package/src/index.ts

@@ -0,0 +1,382 @@
+import { TypedEmitter } from './lib/typedEventEmitter';
+import NativeFlic2, {
+  type ButtonEvent,
+  type FlicButton,
+  type LatencyModeType,
+  type ManagerStateChangeEvent,
+  type ScanStatusChangeEvent,
+  type TriggerModeType,
+} from './NativeFlic2';
+
+class Flic2 {
+
+  private isFlic2ManagerInitialized: boolean = false;
+
+  private sessionId: string;
+
+  public eventEmitter: TypedEmitter<{
+    buttonEvent: (event: ButtonEvent) => void;
+    managerStateChange: (event: ManagerStateChangeEvent) => void;
+    scanStatusChange: (event: ScanStatusChangeEvent) => void;
+    managerInitialized: () => void;
+  }>;
+
+  /**
+   * Constructor.
+   *
+   * @class
+   * @version 2.0.0
+   */
+  constructor() {
+
+    // generate a random session ID for the instance
+    this.sessionId = Math.random().toString(36).substring(2, 15);
+
+    console.log('Created new Flic2 instance with sessionId', this.sessionId);
+
+    // create event emitter
+    this.eventEmitter = new TypedEmitter<{
+      buttonEvent: (event: ButtonEvent) => void;
+      managerStateChange: (event: ManagerStateChangeEvent) => void;
+      scanStatusChange: (event: ScanStatusChangeEvent) => void;
+    }>();
+
+    // listen
+    NativeFlic2.onButtonEvent(this.onNativeButtonEvent.bind(this));
+    NativeFlic2.onManagerStateChange(
+      this.onNativeManagerStateChange.bind(this)
+    );
+
+    NativeFlic2.onScanStatusChange(this.onNativeScanStatusChange.bind(this));
+
+  }
+
+  // MARK: Public management methods
+  /**
+   * Initialize the Flic2 manager.
+   *
+   * @returns A promise that resolves when the Flic2 manager is initialized.
+   */
+  public async initialize(): Promise<boolean> {
+
+    // check if the Flic2 manager is already initialized
+    if (this.isInitialized()) {
+
+      throw new Error('Flic2 manager is already initialized');
+
+    }
+
+    // initialize the Flic2 manager in background
+    const result = await NativeFlic2.initialize(true);
+
+    if (!result.success) {
+
+      throw new Error(result.message);
+
+    }
+
+    this.onInitialized();
+
+    return true;
+
+  }
+
+  /**
+   * Scan for buttons.
+   *
+   * @returns A promise that resolves when the scan is started. Events will be emitted for the scan process.
+   */
+  public startScan(): Promise<{ success: boolean; message: string }> {
+
+    return NativeFlic2.scanForButtons();
+
+  }
+
+  /**
+   * Stop the scan.
+   *
+   * @returns A promise that resolves when the scan is stopped.
+   */
+  public stopScan(): Promise<{ success: boolean; message: string }> {
+
+    return NativeFlic2.stopScan();
+
+  }
+
+  /**
+   * Called when the Flic2 manager is initialized.
+   */
+  public onInitialized(): void {
+
+    this.isFlic2ManagerInitialized = true;
+
+  }
+
+  /**
+   * Check if the Flic2 manager is initialized.
+   *
+   * @returns True if the Flic2 manager is initialized, false otherwise.
+   */
+  public isInitialized(): boolean {
+
+    return this.isFlic2ManagerInitialized;
+
+  }
+
+  /**
+   * Connect all known buttons.
+   *
+   * @returns A promise that resolves when the all known buttons are connected.
+   */
+  public connectAllKnownButtons(): Promise<{
+    success: boolean;
+    message: string;
+  }> {
+
+    return NativeFlic2.connectAllKnownButtons();
+
+  }
+
+  /**
+   * Disconnect all known buttons.
+   *
+   * @returns A promise that resolves when the all known buttons are disconnected.
+   */
+  public disconnectAllKnownButtons(): Promise<{
+    success: boolean;
+    message: string;
+  }> {
+
+    return NativeFlic2.disconnectAllKnownButtons();
+
+  }
+
+  /**
+   * Forget all buttons.
+   *
+   * @returns A promise that resolves when the all buttons are forgotten.
+   */
+  public forgetAllButtons(): Promise<{ success: boolean; message: string }> {
+
+    return NativeFlic2.forgetAllButtons();
+
+  }
+
+  /**
+   * Check if a scan is currently running.
+   *
+   * @returns A promise that resolves to true if scanning, false otherwise.
+   */
+  public isScanning(): Promise<boolean> {
+
+    return NativeFlic2.isScanning();
+
+  }
+
+  /**
+   * Forget a specific button by UUID.
+   *
+   * @param uuid - The UUID of the button to forget.
+   * @returns A promise that resolves when the button is forgotten.
+   */
+  public forgetButton(
+    uuid: string
+  ): Promise<{ success: boolean; message: string }> {
+
+    return NativeFlic2.forgetButton(uuid);
+
+  }
+
+  // MARK: Public button methods
+  /**
+   * Connect a button.
+   *
+   * @param uuid - The UUID of the button to connect.
+   * @returns A promise that resolves when the button is connected.
+   */
+  public buttonConnect(
+    uuid: string
+  ): Promise<{ success: boolean; message: string }> {
+
+    return NativeFlic2.connectButton(uuid);
+
+  }
+
+  /**
+   * Disconnect a button.
+   *
+   * @param uuid - The UUID of the button to disconnect.
+   * @returns A promise that resolves when the button is disconnected.
+   */
+  public buttonDisconnect(
+    uuid: string
+  ): Promise<{ success: boolean; message: string }> {
+
+    return NativeFlic2.disconnectButton(uuid);
+
+  }
+
+  /**
+   * Set the trigger mode of a button.
+   *
+   * @param uuid - The UUID of the button to set the trigger mode of.
+   * @param mode - The trigger mode to set.
+   * @returns A promise that resolves when the trigger mode is set.
+   */
+  public buttonSetTriggerMode(
+    uuid: string,
+    mode: TriggerModeType
+  ): Promise<{ success: boolean; message: string }> {
+
+    return NativeFlic2.setTriggerMode(uuid, mode);
+
+  }
+
+  /**
+   * Set the latency mode of a button.
+   *
+   * @param uuid - The UUID of the button to set the latency mode of.
+   * @param mode - The latency mode to set.
+   * @returns A promise that resolves when the latency mode is set.
+   */
+  public buttonSetLatencyMode(
+    uuid: string,
+    mode: LatencyModeType
+  ): Promise<{ success: boolean; message: string }> {
+
+    return NativeFlic2.setLatencyMode(uuid, mode);
+
+  }
+
+  /**
+   * Set the nickname of a button.
+   *
+   * @param uuid - The UUID of the button to set the nickname of.
+   * @param nickname - The nickname to set.
+   * @returns A promise that resolves when the nickname is set.
+   */
+  public buttonSetNickname(
+    uuid: string,
+    nickname: string
+  ): Promise<{ success: boolean; message: string }> {
+
+    return NativeFlic2.setNickname(uuid, nickname);
+
+  }
+
+  /**
+   * Get all buttons.
+   *
+   * @returns A promise that resolves with an array of FlicButton instances.
+   */
+  public getButtons(): Promise<FlicButton[]> {
+
+    return NativeFlic2.getButtons();
+
+  }
+
+  /**
+   * Get a button by UUID.
+   *
+   * @param uuid - The UUID of the button to get.
+   * @returns A promise that resolves with the FlicButton instance or null if the button is not found.
+   */
+  public async getButton(uuid: string): Promise<FlicButton | null> {
+
+    const buttons = await NativeFlic2.getButtons();
+    const button = buttons.find((item: FlicButton) => item.uuid === uuid);
+
+    return button ?? null;
+
+  }
+
+  /**
+   * Get the battery health status of a button.
+   *
+   * @param uuid - The UUID of the button to check.
+   * @returns A promise that resolves to true if battery is OK (voltage > 2.65V), false otherwise.
+   * @throws Error if the button is not found.
+   */
+  public async getBatteryHealth(uuid: string): Promise<boolean> {
+
+    const button = await this.getButton(uuid);
+
+    if (!button) {
+
+      throw new Error(`Button with UUID ${uuid} not found`);
+
+    }
+
+    return this.isBatteryVoltageOk(button.batteryVoltage);
+
+  }
+
+  // MARK: Private Methods
+  /**
+   * Check if battery voltage is OK based on the 2.65V threshold.
+   *
+   * @param voltage - The battery voltage in volts.
+   * @returns True if voltage is above 2.65V (battery is OK), false otherwise.
+   */
+  private isBatteryVoltageOk(voltage: number): boolean {
+
+    return voltage * 1000 > 2650;
+
+  }
+
+  /**
+   * Called when a button event is received from the native side.
+   *
+   * @param event - The button event.
+   */
+  private onNativeButtonEvent(event: ButtonEvent): void {
+
+    // Enrich batteryUpdate events with batteryVoltageOk
+    if (event.event === 'batteryUpdate') {
+
+      const voltage = typeof event.voltage === 'number' ? event.voltage : event.button?.batteryVoltage;
+
+      const enrichedEvent: ButtonEvent = {
+        ...event,
+        batteryVoltageOk: this.isBatteryVoltageOk(voltage ?? 0),
+      };
+
+      this.eventEmitter.emit('buttonEvent', enrichedEvent);
+
+      return;
+
+    }
+
+    this.eventEmitter.emit('buttonEvent', event);
+
+  }
+
+  /**
+   * Called when a manager state change event is received from the native side.
+   *
+   * @param event - The manager state change event.
+   */
+  private onNativeManagerStateChange(event: ManagerStateChangeEvent): void {
+
+    this.eventEmitter.emit('managerStateChange', event);
+
+  }
+
+  /**
+   * Called when a scan status change event is received from the native side.
+   *
+   * @param event - The scan status change event.
+   */
+  private onNativeScanStatusChange(event: ScanStatusChangeEvent): void {
+
+    this.eventEmitter.emit('scanStatusChange', event);
+
+  }
+
+}
+
+// export as singleton
+export default new Flic2();
+
+// re-export types
+export type * from './NativeFlic2';

package/src/lib/typedEventEmitter.ts

@@ -0,0 +1,63 @@
+type EventMap = Record<string, (...args: any[]) => void>;
+
+export class TypedEmitter<E extends EventMap> {
+
+  private listeners: { [K in keyof E]?: Set<E[K]> } = {};
+
+  on<K extends keyof E>(event: K, fn: E[K]): { remove: () => void } {
+
+    (this.listeners[event] ??= new Set()).add(fn);
+
+    // return shorthand for removing the listener
+    return { remove: () => this.off(event, fn) };
+
+  }
+
+  off<K extends keyof E>(event: K, fn: E[K]): this {
+
+    this.listeners[event]?.delete(fn);
+    return this;
+
+  }
+
+  once<K extends keyof E>(event: K, fn: E[K]): { remove: () => void } {
+
+    const wrapped: E[K] = ((...args: Parameters<E[K]>) => {
+
+      this.off(event, wrapped);
+      fn(...args);
+
+    }) as E[K];
+
+    return this.on(event, wrapped);
+
+  }
+
+  emit<K extends keyof E>(event: K, ...args: Parameters<E[K]>): boolean {
+
+    const ls = this.listeners[event];
+
+    if (!ls || ls.size === 0) {
+
+      return false;
+
+    }
+
+    for (const fn of [...ls]) {
+
+      fn(...args);
+
+    }
+
+    return true;
+
+  }
+
+  clear(): this {
+
+    this.listeners = {};
+    return this;
+
+  }
+
+}

package/src/index.tsx

@@ -1,159 +0,0 @@
-import type { CodegenTypes } from 'react-native';
-import type {
-  MultiplyEvent,
-  ManagerStateChangeEvent,
-  ScanStatusChangeEvent,
-  ButtonEvent,
-  FlicButton,
-  TriggerModeType,
-  LatencyModeType,
-} from './NativeFlic2';
-import NativeFlic2 from './NativeFlic2';
-
-// MARK: - Example Functions (keeping for compatibility)
-
-export function multiply(a: number, b: number): number {
-  return NativeFlic2.multiply(a, b);
-}
-
-export const onMultiply =
-  NativeFlic2.onMultiply as CodegenTypes.EventEmitter<MultiplyEvent>;
-
-// MARK: - Manager Functions
-
-export function initialize(
-  background: boolean
-): Promise<{ success: boolean; message: string }> {
-  return NativeFlic2.initialize(background);
-}
-
-export function getButtons(): Promise<FlicButton[]> {
-  return NativeFlic2.getButtons();
-}
-
-export function scanForButtons(): Promise<{
-  success: boolean;
-  message: string;
-}> {
-  return NativeFlic2.scanForButtons();
-}
-
-export function stopScan(): Promise<{ success: boolean; message: string }> {
-  return NativeFlic2.stopScan();
-}
-
-export function forgetButton(
-  uuid: string
-): Promise<{ success: boolean; message: string }> {
-  return NativeFlic2.forgetButton(uuid);
-}
-
-export function connectAllKnownButtons(): Promise<{
-  success: boolean;
-  message: string;
-}> {
-  return NativeFlic2.connectAllKnownButtons();
-}
-
-export function disconnectAllKnownButtons(): Promise<{
-  success: boolean;
-  message: string;
-}> {
-  return NativeFlic2.disconnectAllKnownButtons();
-}
-
-export function forgetAllButtons(): Promise<{
-  success: boolean;
-  message: string;
-}> {
-  return NativeFlic2.forgetAllButtons();
-}
-
-export function isScanning(): Promise<boolean> {
-  return NativeFlic2.isScanning();
-}
-
-// MARK: - Button Functions
-
-export function connectButton(
-  uuid: string
-): Promise<{ success: boolean; message: string }> {
-  return NativeFlic2.connectButton(uuid);
-}
-
-export function disconnectButton(
-  uuid: string
-): Promise<{ success: boolean; message: string }> {
-  return NativeFlic2.disconnectButton(uuid);
-}
-
-/**
- * Sets the trigger mode for a button.
- *
- * @platform iOS
- * @param uuid - Button UUID
- * @param mode - Trigger mode (0-3)
- * @returns Promise that resolves on iOS, rejects with NOT_SUPPORTED_ON_ANDROID on Android
- *
- * **Note:** This feature is only available on iOS. On Android, this will reject due to
- * limitations in the Android Flic2 library v1.1.0+.
- */
-export function setTriggerMode(
-  uuid: string,
-  mode: TriggerModeType
-): Promise<{ success: boolean; message: string }> {
-  return NativeFlic2.setTriggerMode(uuid, mode);
-}
-
-/**
- * Sets the latency mode for a button.
- *
- * @platform iOS
- * @param uuid - Button UUID
- * @param mode - Latency mode (0-1)
- * @returns Promise that resolves on iOS, rejects with NOT_SUPPORTED_ON_ANDROID on Android
- *
- * **Note:** This feature is only available on iOS. On Android, this will reject due to
- * limitations in the Android Flic2 library v1.1.0+.
- */
-export function setLatencyMode(
-  uuid: string,
-  mode: LatencyModeType
-): Promise<{ success: boolean; message: string }> {
-  return NativeFlic2.setLatencyMode(uuid, mode);
-}
-
-export function setNickname(
-  uuid: string,
-  nickname: string
-): Promise<{ success: boolean; message: string }> {
-  return NativeFlic2.setNickname(uuid, nickname);
-}
-
-// MARK: - Event Emitters
-
-export const onManagerStateChange =
-  NativeFlic2.onManagerStateChange as CodegenTypes.EventEmitter<ManagerStateChangeEvent>;
-
-export const onScanStatusChange =
-  NativeFlic2.onScanStatusChange as CodegenTypes.EventEmitter<ScanStatusChangeEvent>;
-
-export const onButtonEvent =
-  NativeFlic2.onButtonEvent as CodegenTypes.EventEmitter<ButtonEvent>;
-
-// MARK: - Re-export Types
-
-export type {
-  MultiplyEvent,
-  ManagerStateChangeEvent,
-  ScanStatusChangeEvent,
-  ButtonEvent,
-  FlicButton,
-  FlicManagerState,
-  FlicButtonState,
-  FlicTriggerMode,
-  FlicLatencyMode,
-  FlicScannerEvent,
-  TriggerModeType,
-  LatencyModeType,
-} from './NativeFlic2';