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

package/src/index.ts

@@ -0,0 +1,360 @@
+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;
+
+  public eventEmitter: TypedEmitter<{
+    buttonEvent: (event: ButtonEvent) => void;
+    managerStateChange: (event: ManagerStateChangeEvent) => void;
+    scanStatusChange: (event: ScanStatusChangeEvent) => void;
+  }>;
+
+  /**
+   * Constructor.
+   *
+   * @class
+   * @version 2.0.0
+   */
+  constructor() {
+
+    // 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<void> {
+
+    // 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
+    await NativeFlic2.initialize(true);
+
+    this.onInitialized();
+
+  }
+
+  /**
+   * Scan for buttons.
+   *
+   * @returns A promise that resolves when the scan is started. Events will be emitted for the scan process.
+   */
+  public startScan(): Promise<void> {
+
+    return NativeFlic2.scanForButtons();
+
+  }
+
+  /**
+   * Stop the scan.
+   *
+   * @returns A promise that resolves when the scan is stopped.
+   */
+  public stopScan(): Promise<void> {
+
+    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<void> {
+
+    return NativeFlic2.connectAllKnownButtons();
+
+  }
+
+  /**
+   * Disconnect all known buttons.
+   *
+   * @returns A promise that resolves when the all known buttons are disconnected.
+   */
+  public disconnectAllKnownButtons(): Promise<void> {
+
+    return NativeFlic2.disconnectAllKnownButtons();
+
+  }
+
+  /**
+   * Forget all buttons.
+   *
+   * @returns A promise that resolves when the all buttons are forgotten.
+   */
+  public forgetAllButtons(): Promise<void> {
+
+    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<void> {
+
+    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 with the button when the connection is initiated.
+   */
+  public buttonConnect(
+    uuid: string
+  ): Promise<FlicButton> {
+
+    return NativeFlic2.connectButton(uuid);
+
+  }
+
+  /**
+   * Disconnect a button.
+   *
+   * @param uuid - The UUID of the button to disconnect.
+   * @returns A promise that resolves with the button when the disconnection is initiated.
+   */
+  public buttonDisconnect(
+    uuid: string
+  ): Promise<FlicButton> {
+
+    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 with the button when the trigger mode is set.
+   */
+  public buttonSetTriggerMode(
+    uuid: string,
+    mode: TriggerModeType
+  ): Promise<FlicButton> {
+
+    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 with the button when the latency mode is set.
+   */
+  public buttonSetLatencyMode(
+    uuid: string,
+    mode: LatencyModeType
+  ): Promise<FlicButton> {
+
+    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 with the button when the nickname is set.
+   */
+  public buttonSetNickname(
+    uuid: string,
+    nickname: string
+  ): Promise<FlicButton> {
+
+    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/android/src/main/java/com/flic2/Flic2Service.kt

@@ -1,112 +0,0 @@
-package com.flic2
-
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.app.Service
-import android.content.Intent
-import android.os.Binder
-import android.os.Build
-import android.os.Handler
-import android.os.IBinder
-import android.os.Looper
-import android.util.Log
-import androidx.core.app.NotificationCompat
-import io.flic.flic2libandroid.Flic2Manager
-
-class Flic2Service : Service() {
-
-    private val binder = Flic2ServiceBinder()
-    private var manager: Flic2Manager? = null
-
-    companion object {
-        private const val TAG = "Flic2Service"
-        private const val NOTIFICATION_ID = 1
-        private const val CHANNEL_ID = "Flic2ServiceChannel"
-        private const val CHANNEL_NAME = "Flic2 Service"
-    }
-
-    inner class Flic2ServiceBinder : Binder() {
-        fun getService(): Flic2Service = this@Flic2Service
-    }
-
-    override fun onCreate() {
-        super.onCreate()
-        Log.d(TAG, "Service onCreate")
-
-        try {
-            // Initialize Flic2Manager on main thread with Handler
-            // v1.1.0 API: init() returns void, must call getInstance() after
-            Flic2Manager.init(
-                applicationContext,
-                Handler(Looper.getMainLooper())
-            )
-            manager = Flic2Manager.getInstance()
-            Log.d(TAG, "Flic2Manager initialized successfully")
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to initialize Flic2Manager", e)
-        }
-    }
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        Log.d(TAG, "Service onStartCommand")
-
-        // Create notification channel for Android O and above
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(
-                CHANNEL_ID,
-                CHANNEL_NAME,
-                NotificationManager.IMPORTANCE_LOW
-            ).apply {
-                description = "Keeps Flic2 buttons connected in the background"
-                setShowBadge(false)
-            }
-
-            val notificationManager = getSystemService(NotificationManager::class.java)
-            notificationManager.createNotificationChannel(channel)
-        }
-
-        // Create notification
-        val notification = createNotification()
-
-        // Start as foreground service
-        startForeground(NOTIFICATION_ID, notification)
-
-        return START_STICKY
-    }
-
-    override fun onBind(intent: Intent?): IBinder {
-        Log.d(TAG, "Service onBind")
-        return binder
-    }
-
-    override fun onDestroy() {
-        Log.d(TAG, "Service onDestroy")
-        super.onDestroy()
-    }
-
-    fun getManager(): Flic2Manager? = manager
-
-    fun isManagerInitialized(): Boolean = manager != null
-
-    private fun createNotification(): Notification {
-        val notificationIntent = Intent(this, Flic2Service::class.java)
-        val pendingIntent = PendingIntent.getActivity(
-            this,
-            0,
-            notificationIntent,
-            PendingIntent.FLAG_IMMUTABLE
-        )
-
-        return NotificationCompat.Builder(this, CHANNEL_ID)
-            .setContentTitle("Flic2 Service")
-            .setContentText("Flic2 buttons are connected")
-            .setSmallIcon(android.R.drawable.ic_dialog_info)
-            .setContentIntent(pendingIntent)
-            .setPriority(NotificationCompat.PRIORITY_LOW)
-            .setOngoing(true)
-            .build()
-    }
-}
-

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';