react-native-flic2 0.3.26 → 2.0.0-alpha.39

package/android/src/main/java/com/flic2/Flic2Module.kt

@@ -0,0 +1,480 @@
+package com.flic2
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.os.Build
+import android.os.IBinder
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import io.flic.flic2libandroid.Flic2Button
+import io.flic.flic2libandroid.Flic2Manager
+import io.flic.flic2libandroid.Flic2ScanCallback
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withTimeout
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+// Custom exception for scan errors with error codes
+class ScanException(val errorCode: String, val code: Int, message: String) : Exception(message)
+
+@ReactModule(name = Flic2Module.NAME)
+class Flic2Module(reactContext: ReactApplicationContext) :
+  NativeFlic2Spec(reactContext) {
+
+  private var flic2Service: Flic2Service? = null
+  private var serviceBound = false
+  private val moduleScope = CoroutineScope(Dispatchers.Main + Job())
+  private var scanJob: Job? = null
+  private val buttonListeners = mutableMapOf<String, Flic2ButtonEventListener>()
+  private var initializePromise: Promise? = null
+
+  companion object {
+    const val NAME = "Flic2"
+    private const val TAG = "Flic2Module"
+  }
+
+  private val serviceConnection = object : ServiceConnection {
+    override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
+      Log.d(TAG, "Service connected")
+      val binder = service as Flic2Service.Flic2ServiceBinder
+      flic2Service = binder.getService()
+      serviceBound = true
+
+      // Set up listeners for existing buttons
+      flic2Service?.getManager()?.let { manager ->
+        manager.buttons.forEach { button ->
+          setupButtonListener(button)
+        }
+      }
+
+      // Resolve the initialize promise if pending
+      initializePromise?.let { promise ->
+        promise.resolve(Arguments.createMap().apply {
+          putBoolean("success", true)
+          putString("message", "Manager initialized successfully")
+        })
+        initializePromise = null
+      }
+    }
+
+    override fun onServiceDisconnected(name: ComponentName?) {
+      Log.d(TAG, "Service disconnected")
+      serviceBound = false
+      flic2Service = null
+
+      // Reject any pending initialize promise
+      initializePromise?.let { promise ->
+        promise.reject("SERVICE_DISCONNECTED", "Service disconnected unexpectedly")
+        initializePromise = null
+      }
+    }
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  override fun invalidate() {
+    super.invalidate()
+    moduleScope.cancel()
+    if (serviceBound) {
+      reactApplicationContext.unbindService(serviceConnection)
+      serviceBound = false
+    }
+  }
+
+  // Example method - keep for reference
+  override fun multiply(a: Double, b: Double): Double {
+    val result = a * b
+
+    val eventData = Arguments.createMap().apply {
+      putDouble("a", a)
+      putDouble("b", b)
+      putDouble("result", result)
+    }
+    emitOnMultiply(eventData)
+
+    return result
+  }
+
+  // MARK: - Manager Methods
+
+  override fun initialize(background: Boolean, promise: Promise) {
+    try {
+      // Store the promise to resolve when service is connected
+      initializePromise = promise
+
+      val intent = Intent(reactApplicationContext, Flic2Service::class.java)
+
+      // Start service
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        reactApplicationContext.startForegroundService(intent)
+      } else {
+        reactApplicationContext.startService(intent)
+      }
+
+      // Bind to service - promise will be resolved in onServiceConnected
+      val bound = reactApplicationContext.bindService(
+        intent,
+        serviceConnection,
+        Context.BIND_AUTO_CREATE
+      )
+
+      if (!bound) {
+        initializePromise = null
+        promise.reject("INIT_ERROR", "Failed to bind to service")
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to initialize", e)
+      initializePromise = null
+      promise.reject("INIT_ERROR", "Failed to initialize: ${e.message}", e)
+    }
+  }
+
+  override fun getButtons(promise: Promise) {
+    try {
+      val manager = flic2Service?.getManager()
+      if (manager == null) {
+        promise.reject("NOT_INITIALIZED", "Manager not initialized")
+        return
+      }
+
+      val buttons = manager.buttons
+      val buttonArray = Flic2Converter.buttonsToArray(buttons)
+      promise.resolve(buttonArray)
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to get buttons", e)
+      promise.reject("GET_BUTTONS_ERROR", "Failed to get buttons: ${e.message}", e)
+    }
+  }
+
+  override fun scanForButtons(promise: Promise) {
+    val manager = flic2Service?.getManager()
+    if (manager == null) {
+      promise.reject("NOT_INITIALIZED", "Manager not initialized")
+      return
+    }
+
+    // Cancel any existing scan
+    scanJob?.cancel()
+
+    Log.d(TAG, "Starting scan")
+
+    manager.startScan(object : Flic2ScanCallback {
+      override fun onDiscoveredAlreadyPairedButton(button: Flic2Button) {
+        Log.d(TAG, "Discovered already paired button")
+        emitOnScanStatusChange(Arguments.createMap().apply {
+          putInt("event", 0)
+          putString("eventName", "discovered")
+        })
+      }
+
+      override fun onDiscovered(bdAddr: String) {
+        Log.d(TAG, "Discovered button: $bdAddr")
+        emitOnScanStatusChange(Arguments.createMap().apply {
+          putInt("event", 0)
+          putString("eventName", "discovered")
+        })
+      }
+
+      override fun onConnected() {
+        Log.d(TAG, "Button connected during scan")
+        emitOnScanStatusChange(Arguments.createMap().apply {
+          putInt("event", 1)
+          putString("eventName", "connected")
+        })
+      }
+
+      override fun onComplete(result: Int, subCode: Int, button: Flic2Button?) {
+        Log.d(TAG, "Scan complete: result=$result, button=${button?.uuid}")
+
+        if (result == Flic2ScanCallback.RESULT_SUCCESS && button != null) {
+          emitOnScanStatusChange(Arguments.createMap().apply {
+            putInt("event", 2)
+            putString("eventName", "verified")
+          })
+
+          // Auto-connect (trigger mode not available in Android v1.1.0+)
+          button.connect()
+
+          setupButtonListener(button)
+
+          // Emit discovered event
+          emitOnButtonEvent(Arguments.createMap().apply {
+            putString("uuid", button.uuid)
+            putString("event", "discovered")
+            putMap("button", Flic2Converter.buttonToMap(button))
+          })
+        } else {
+          val errorCode = Flic2Converter.scanResultToString(result)
+          Log.e(TAG, "Scan failed with error code: $errorCode")
+        }
+      }
+    })
+
+    // Return immediately - scan results will come through events
+    promise.resolve(Arguments.createMap().apply {
+      putBoolean("success", true)
+      putString("message", "Scan started")
+    })
+  }
+
+  override fun stopScan(promise: Promise) {
+    try {
+      val manager = flic2Service?.getManager()
+      if (manager == null) {
+        promise.reject("NOT_INITIALIZED", "Manager not initialized")
+        return
+      }
+
+      scanJob?.cancel()
+      manager.stopScan()
+
+      promise.resolve(Arguments.createMap().apply {
+        putBoolean("success", true)
+        putString("message", "Scan stopped")
+      })
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to stop scan", e)
+      promise.reject("STOP_SCAN_ERROR", "Failed to stop scan: ${e.message}", e)
+    }
+  }
+
+  override fun forgetButton(uuid: String, promise: Promise) {
+    try {
+      val manager = flic2Service?.getManager()
+      if (manager == null) {
+        promise.reject("NOT_INITIALIZED", "Manager not initialized")
+        return
+      }
+
+      val button = manager.buttons.find { it.uuid == uuid }
+      if (button == null) {
+        promise.reject("BUTTON_NOT_FOUND", "Button not found")
+        return
+      }
+
+      // Disconnect before forgetting like iOS
+      button.disconnectOrAbortPendingConnection()
+
+      // Remove listener
+      buttonListeners.remove(uuid)
+
+      // Forget button
+      manager.forgetButton(button)
+
+      promise.resolve(Arguments.createMap().apply {
+        putBoolean("success", true)
+        putString("message", "Button forgotten")
+      })
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to forget button", e)
+      promise.reject("FORGET_ERROR", "Failed to forget button: ${e.message}", e)
+    }
+  }
+
+  // MARK: - Button Methods
+
+  override fun connectButton(uuid: String, promise: Promise) {
+    try {
+      val button = findButton(uuid)
+      if (button == null) {
+        promise.reject("BUTTON_NOT_FOUND", "Button not found")
+        return
+      }
+
+      button.connect()
+
+      promise.resolve(Arguments.createMap().apply {
+        putBoolean("success", true)
+        putString("message", "Connection initiated")
+      })
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to connect button", e)
+      promise.reject("CONNECT_ERROR", "Failed to connect: ${e.message}", e)
+    }
+  }
+
+  override fun disconnectButton(uuid: String, promise: Promise) {
+    try {
+      val button = findButton(uuid)
+      if (button == null) {
+        promise.reject("BUTTON_NOT_FOUND", "Button not found")
+        return
+      }
+
+      button.disconnectOrAbortPendingConnection()
+
+      promise.resolve(Arguments.createMap().apply {
+        putBoolean("success", true)
+        putString("message", "Disconnection initiated")
+      })
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to disconnect button", e)
+      promise.reject("DISCONNECT_ERROR", "Failed to disconnect: ${e.message}", e)
+    }
+  }
+
+  override fun setTriggerMode(uuid: String, mode: Double, promise: Promise) {
+    promise.reject(
+        "NOT_SUPPORTED_ON_ANDROID",
+        "Trigger mode is only supported on iOS. Android Flic2 library v1.1.0+ does not support trigger modes."
+    )
+  }
+
+  override fun setLatencyMode(uuid: String, mode: Double, promise: Promise) {
+    promise.reject(
+        "NOT_SUPPORTED_ON_ANDROID",
+        "Latency mode is only supported on iOS. Android Flic2 library v1.1.0+ does not support latency modes."
+    )
+  }
+
+  override fun setNickname(uuid: String, nickname: String, promise: Promise) {
+    try {
+      val button = findButton(uuid)
+      if (button == null) {
+        promise.reject("BUTTON_NOT_FOUND", "Button not found")
+        return
+      }
+
+      // v1.1.0 uses setName() method instead of property
+      button.setName(nickname)
+
+      promise.resolve(Arguments.createMap().apply {
+        putBoolean("success", true)
+        putString("message", "Nickname set")
+      })
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to set nickname", e)
+      promise.reject("SET_NICKNAME_ERROR", "Failed to set nickname: ${e.message}", e)
+    }
+  }
+
+  override fun connectAllKnownButtons(promise: Promise) {
+    try {
+      val manager = flic2Service?.getManager()
+      if (manager == null) {
+        promise.reject("NOT_INITIALIZED", "Manager not initialized")
+        return
+      }
+
+      val buttons = manager.buttons
+
+      buttons.forEach { button ->
+        Log.d(TAG, "Connecting button: ${button.getName()}")
+        // Trigger mode not available in Android v1.1.0+
+        button.connect()
+      }
+
+      promise.resolve(Arguments.createMap().apply {
+        putBoolean("success", true)
+        putString("message", "All buttons connection initiated")
+      })
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to connect all buttons", e)
+      promise.reject("CONNECT_ALL_ERROR", "Failed to connect all buttons: ${e.message}", e)
+    }
+  }
+
+  override fun disconnectAllKnownButtons(promise: Promise) {
+    try {
+      val manager = flic2Service?.getManager()
+      if (manager == null) {
+        promise.reject("NOT_INITIALIZED", "Manager not initialized")
+        return
+      }
+
+      val buttons = manager.buttons
+
+      buttons.forEach { button ->
+        Log.d(TAG, "Disconnecting button: ${button.name}")
+        button.disconnectOrAbortPendingConnection()
+      }
+
+      promise.resolve(Arguments.createMap().apply {
+        putBoolean("success", true)
+        putString("message", "All buttons disconnection initiated")
+      })
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to disconnect all buttons", e)
+      promise.reject("DISCONNECT_ALL_ERROR", "Failed to disconnect all buttons: ${e.message}", e)
+    }
+  }
+
+  override fun forgetAllButtons(promise: Promise) {
+    try {
+      val manager = flic2Service?.getManager()
+      if (manager == null) {
+        promise.reject("NOT_INITIALIZED", "Manager not initialized")
+        return
+      }
+
+      // Create a copy of the list to avoid concurrent modification
+      val buttons = manager.buttons.toList()
+
+      buttons.forEach { button ->
+        buttonListeners.remove(button.uuid)
+        button.disconnectOrAbortPendingConnection()
+        manager.forgetButton(button)
+      }
+
+      promise.resolve(Arguments.createMap().apply {
+        putBoolean("success", true)
+        putString("message", "All buttons forgotten")
+      })
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to forget all buttons", e)
+      promise.reject("FORGET_ALL_ERROR", "Failed to forget all buttons: ${e.message}", e)
+    }
+  }
+
+  override fun isScanning(promise: Promise) {
+    try {
+      val manager = flic2Service?.getManager()
+      if (manager == null) {
+        promise.reject("NOT_INITIALIZED", "Manager not initialized")
+        return
+      }
+
+      val scanning = (scanJob != null && scanJob?.isActive == true)
+      promise.resolve(scanning)
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to check scanning status", e)
+      promise.reject("IS_SCANNING_ERROR", "Failed to check scanning status: ${e.message}", e)
+    }
+  }
+
+  // MARK: - Helper Methods
+
+  private fun findButton(uuid: String): Flic2Button? {
+    return flic2Service?.getManager()?.buttons?.find { it.uuid == uuid }
+  }
+
+  private fun setupButtonListener(button: Flic2Button) {
+    // Remove existing listener if any
+    buttonListeners.remove(button.uuid)
+
+    // Create new listener
+    val listener = Flic2ButtonEventListener { event ->
+      emitOnButtonEvent(event)
+    }
+
+    // Add listener to button
+    button.addListener(listener)
+
+    // Store listener reference
+    buttonListeners[button.uuid] = listener
+  }
+}

package/android/src/main/java/com/flic2/Flic2Package.kt

@@ -0,0 +1,33 @@
+package com.flic2
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class Flic2Package : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == Flic2Module.NAME) {
+      Flic2Module(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[Flic2Module.NAME] = ReactModuleInfo(
+        Flic2Module.NAME,
+        Flic2Module.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/android/src/main/java/com/flic2/Flic2Service.kt

@@ -0,0 +1,112 @@
+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/ios/Flic2.h

@@ -1,7 +1,12 @@
-
+#import <Flic2Spec/Flic2Spec.h>
+#import <flic2lib/FLICManager.h>
+#import <flic2lib/FLICButton.h>
+#import <flic2lib/FLICEnums.h>
 #import <React/RCTBridgeModule.h>
-#import <React/RCTEventEmitter.h>
-@import flic2lib;
 
-@interface Flic2 : RCTEventEmitter <FLICButtonDelegate, FLICManagerDelegate, RCTBridgeModule>
+@interface Flic2 : NativeFlic2SpecBase <NativeFlic2Spec, FLICManagerDelegate, FLICButtonDelegate>
+
+@property (nonatomic, strong) FLICManager *manager;
+@property (nonatomic, assign) BOOL managerRestored;
+
 @end