react-native-flic2 2.0.0-beta.11 → 2.0.0-beta.12

package/android/build.gradle

@@ -0,0 +1,81 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Flic2_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Flic2_" + name]).toInteger()
+}
+
+android {
+  namespace "nl.xguard.flic2"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+  maven { url 'https://jitpack.io' }
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation 'com.github.50ButtonsEach:flic2lib-android:1.+'
+  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
+  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3'
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+Flic2_kotlinVersion=2.0.21
+Flic2_minSdkVersion=24
+Flic2_targetSdkVersion=34
+Flic2_compileSdkVersion=35
+Flic2_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,50 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <!-- Bluetooth permissions for API < 31 -->
+    <uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" android:maxSdkVersion="30" />
+
+    <!-- Bluetooth permissions for API >= 31 -->
+    <uses-permission android:name="android.permission.BLUETOOTH_SCAN"
+        android:usesPermissionFlags="neverForLocation"
+        tools:targetApi="s" />
+    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+
+    <!-- Foreground service permission -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+
+    <application>
+        <service
+            android:name=".Flic2Service"
+            android:enabled="true"
+            android:exported="false"
+            android:foregroundServiceType="connectedDevice" />
+
+        <receiver
+            android:name=".Flic2Service$BootUpReceiver"
+            android:enabled="true"
+            android:permission="android.permission.RECEIVE_BOOT_COMPLETED"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </receiver>
+
+        <receiver
+            android:name=".Flic2Service$UpdateReceiver"
+            android:enabled="true"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.intent.action.PACKAGE_REPLACED" />
+                <data
+                    android:scheme="package" />
+            </intent-filter>
+        </receiver>
+    </application>
+
+</manifest>

package/android/src/main/java/nl/xguard/flic2/ActivityUtil.kt

@@ -0,0 +1,29 @@
+package nl.xguard.flic2
+
+import android.app.ActivityManager
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+
+object ActivityUtil {
+    private const val TAG = "ActivityUtil"
+
+    fun isServiceRunning(context: Context, serviceClass: Class<*>): Boolean {
+        val manager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+        for (service in manager.getRunningServices(Integer.MAX_VALUE)) {
+            if (serviceClass.name == service.service.className) {
+                return true
+            }
+        }
+        return false
+    }
+
+    fun startForegroundService(context: Context, intent: Intent) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            context.startForegroundService(intent)
+        } else {
+            context.startService(intent)
+        }
+    }
+}
+

package/android/src/main/java/nl/xguard/flic2/Flic2ButtonListener.kt

@@ -0,0 +1,144 @@
+package nl.xguard.flic2
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import io.flic.flic2libandroid.BatteryLevel
+import io.flic.flic2libandroid.Flic2Button
+import io.flic.flic2libandroid.Flic2ButtonListener
+
+class Flic2ButtonEventListener(
+    private val emitEvent: (WritableMap) -> Unit
+) : Flic2ButtonListener() {
+
+    // Map Android library's onConnect() to emit "connected" (matches iOS)
+    override fun onConnect(button: Flic2Button) {
+        emitEvent(createButtonEvent(button, "connected"))
+    }
+
+    // Map Android library's onReady() to emit "ready" (matches iOS)
+    override fun onReady(button: Flic2Button, timestamp: Long) {
+        emitEvent(createButtonEvent(button, "ready"))
+    }
+
+    // Map Android library's onDisconnect() to emit "disconnected" (matches iOS)
+    override fun onDisconnect(button: Flic2Button) {
+        emitEvent(createButtonEvent(button, "disconnected"))
+    }
+
+    // Map Android library's onFailure() to emit "connectionFailed" (matches iOS)
+    override fun onFailure(button: Flic2Button, errorCode: Int, subCode: Int) {
+        emitEvent(createButtonEvent(button, "connectionFailed").apply {
+            putMap("error", Arguments.createMap().apply {
+                putInt("code", errorCode)
+                putInt("subCode", subCode)
+                putString("message", "Connection failed: code=$errorCode, subCode=$subCode")
+            })
+        })
+    }
+
+    override fun onButtonUpOrDown(
+        button: Flic2Button,
+        wasQueued: Boolean,
+        lastQueued: Boolean,
+        timestamp: Long,
+        isUp: Boolean,
+        isDown: Boolean
+    ) {
+        val event = if (isDown) "buttonDown" else "buttonUp"
+        emitEvent(createButtonEvent(button, event).apply {
+            putBoolean("queued", wasQueued)
+            // Match old Android implementation and iOS:
+            // - Age is in seconds
+            // - Only meaningful for queued events; 0 for real-time events
+            val ageSeconds = if (wasQueued) {
+                (button.readyTimestamp - timestamp) / 1000.0
+            } else {
+                0.0
+            }
+            putDouble("age", ageSeconds)
+        })
+    }
+
+    // Android library calls ALL applicable callback methods, causing duplicate events.
+    // Only onButtonSingleOrDoubleClickOrHold should emit events to match iOS behavior.
+    override fun onButtonClickOrHold(
+        button: Flic2Button,
+        wasQueued: Boolean,
+        lastQueued: Boolean,
+        timestamp: Long,
+        isClick: Boolean,
+        isHold: Boolean
+    ) {
+        // Intentionally empty - events are handled by onButtonSingleOrDoubleClickOrHold
+    }
+
+    // Android library calls ALL applicable callback methods, causing duplicate events.
+    // Only onButtonSingleOrDoubleClickOrHold should emit events to match iOS behavior.
+    override fun onButtonSingleOrDoubleClick(
+        button: Flic2Button,
+        wasQueued: Boolean,
+        lastQueued: Boolean,
+        timestamp: Long,
+        isSingleClick: Boolean,
+        isDoubleClick: Boolean
+    ) {
+        // Intentionally empty - events are handled by onButtonSingleOrDoubleClickOrHold
+    }
+
+    override fun onButtonSingleOrDoubleClickOrHold(
+        button: Flic2Button,
+        wasQueued: Boolean,
+        lastQueued: Boolean,
+        timestamp: Long,
+        isSingleClick: Boolean,
+        isDoubleClick: Boolean,
+        isHold: Boolean
+    ) {
+        val event = when {
+            isSingleClick -> "click"
+            isDoubleClick -> "doubleClick"
+            isHold -> "hold"
+            else -> "unknown"
+        }
+        emitEvent(createButtonEvent(button, event).apply {
+            putBoolean("queued", wasQueued)
+            // Match old Android implementation and iOS:
+            // - Age is in seconds
+            // - Only meaningful for queued events; 0 for real-time events
+            val ageSeconds = if (wasQueued) {
+                (button.readyTimestamp - timestamp) / 1000.0
+            } else {
+                0.0
+            }
+            putDouble("age", ageSeconds)
+        })
+    }
+
+    // Map Android library's onUnpaired() to emit "unpaired" (matches iOS)
+    override fun onUnpaired(button: Flic2Button) {
+        emitEvent(createButtonEvent(button, "unpaired"))
+    }
+
+    // Map Android library's onBatteryLevelUpdated() to emit "batteryUpdate" (matches iOS)
+    override fun onBatteryLevelUpdated(button: Flic2Button, level: BatteryLevel) {
+        emitEvent(createButtonEvent(button, "batteryUpdate").apply {
+            putDouble("voltage", level.voltage.toDouble())
+        })
+    }
+
+    // Map Android library's onNameUpdated() to emit "nicknameUpdate" (matches iOS)
+    override fun onNameUpdated(button: Flic2Button, newName: String) {
+        emitEvent(createButtonEvent(button, "nicknameUpdate").apply {
+            putString("nickname", newName)
+        })
+    }
+
+    private fun createButtonEvent(button: Flic2Button, event: String): WritableMap {
+        return Arguments.createMap().apply {
+            putString("uuid", button.uuid)
+            putString("event", event)
+            putMap("button", Flic2Converter.buttonToMap(button))
+        }
+    }
+}
+

package/android/src/main/java/nl/xguard/flic2/Flic2Converter.kt

@@ -0,0 +1,105 @@
+package nl.xguard.flic2
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import io.flic.flic2libandroid.Flic2Button
+
+object Flic2Converter {
+
+    fun buttonToMap(button: Flic2Button): WritableMap {
+        return Arguments.createMap().apply {
+            putString("uuid", button.uuid)
+            putString("identifier", button.uuid) // Android uses UUID as identifier
+            putString("name", button.getName() ?: "")
+            putString("nickname", button.getName() ?: "")
+            putString("bluetoothAddress", button.getBdAddr() ?: "")
+            putString("serialNumber", button.getSerialNumber() ?: "")
+
+            // ready timestamp
+            putLong("readyTimestamp", button.getReadyTimestamp())
+
+            // Use connection state constants instead of enum
+            val connState = button.getConnectionState()
+            putInt("state", connectionStateToInt(connState))
+            putString("stateName", connectionStateToString(connState))
+
+            // iOS-only: Return defaults for trigger/latency mode (not supported in Android v1.1.0+)
+            putInt("triggerMode", 0)
+            putString("triggerModeName", "")
+            putInt("latencyMode", 0)
+            putString("latencyModeName", "")
+
+            putInt("pressCount", button.getPressCount())
+            putInt("firmwareRevision", button.getFirmwareVersion())
+
+            // Check if ready by comparing connection state
+            putBoolean("isReady", connState == Flic2Button.CONNECTION_STATE_CONNECTED_READY)
+
+            // Get battery level from BatteryLevel object
+            val batteryLevel = button.getLastKnownBatteryLevel()
+            putDouble("batteryVoltage", batteryLevel?.voltage?.toDouble() ?: 0.0)
+
+            putBoolean("isUnpaired", button.isUnpaired())
+        }
+    }
+
+    fun buttonsToArray(buttons: List<Flic2Button>): WritableArray {
+        return Arguments.createArray().apply {
+            buttons.forEach { button ->
+                pushMap(buttonToMap(button))
+            }
+        }
+    }
+
+    private fun connectionStateToInt(state: Int): Int {
+        return when (state) {
+            Flic2Button.CONNECTION_STATE_DISCONNECTED -> 0
+            Flic2Button.CONNECTION_STATE_CONNECTING -> 1
+            Flic2Button.CONNECTION_STATE_CONNECTED_STARTING -> 2
+            Flic2Button.CONNECTION_STATE_CONNECTED_READY -> 3
+            else -> 0
+        }
+    }
+
+    private fun connectionStateToString(state: Int): String {
+        return when (state) {
+            Flic2Button.CONNECTION_STATE_DISCONNECTED -> "disconnected"
+            Flic2Button.CONNECTION_STATE_CONNECTING -> "connecting"
+            Flic2Button.CONNECTION_STATE_CONNECTED_STARTING -> "connected"
+            Flic2Button.CONNECTION_STATE_CONNECTED_READY -> "connected"
+            else -> "disconnected"
+        }
+    }
+
+    // Trigger mode and latency mode are iOS-only features (removed from Android library v1.1.0+)
+
+    fun scanResultToString(result: Int): String {
+        return when (result) {
+            0 -> "success"
+            1 -> "alreadyRunning"
+            2 -> "bluetoothNotActivated"
+            3 -> "unknown"
+            4 -> "noPublicButtonDiscovered"
+            5 -> "alreadyConnectedToAnotherDevice"
+            6 -> "connectionTimeout"
+            7 -> "invalidVerifier"
+            8 -> "blePairingFailedPreviousPairingAlreadyExisting"
+            9 -> "blePairingFailedUserCanceled"
+            10 -> "blePairingFailedUnknownReason"
+            11 -> "appCredentialsDontMatch"
+            12 -> "userCanceled"
+            13 -> "invalidBluetoothAddress"
+            14 -> "genuineCheckFailed"
+            15 -> "tooManyApps"
+            16 -> "couldNotSetBluetoothNotify"
+            17 -> "couldNotDiscoverBluetoothServices"
+            18 -> "buttonDisconnectedDuringVerification"
+            19 -> "failedToEstablish"
+            20 -> "connectionLimitReached"
+            21 -> "notInPublicMode"
+            else -> "unknown"
+        }
+    }
+}
+

package/android/src/main/java/nl/xguard/flic2/Flic2Module.kt

@@ -0,0 +1,521 @@
+package nl.xguard.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")
+      flic2Service = (service as Flic2Service.Flic2ServiceBinder).getService()
+      serviceBound = true
+
+      // Set up listeners for existing buttons
+      flic2Service?.getManager()?.let { manager ->
+        manager.buttons.forEach { button ->
+          setupButtonListener(button)
+        }
+        // Update foreground service state based on button count
+        updateForegroundServiceState(manager.buttons.size)
+      }
+
+      // Resolve the initialize promise if pending
+      initializePromise?.let { promise ->
+        promise.resolve(null)
+        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()
+
+    // Remove all button listeners before cleanup to prevent callbacks after teardown
+    try {
+      val manager = flic2Service?.getManager()
+      if (manager != null) {
+        buttonListeners.forEach { (uuid, listener) ->
+          try {
+            // Find the button and remove the listener
+            val button = manager.buttons.find { it.uuid == uuid }
+            if (button != null) {
+              button.removeListener(listener)
+              Log.d(TAG, "Removed listener for button during invalidate: $uuid")
+            }
+          } catch (e: Exception) {
+            Log.w(TAG, "Failed to remove listener for button during invalidate: $uuid", e)
+          }
+        }
+      }
+    } catch (e: Exception) {
+      Log.w(TAG, "Error during listener cleanup in invalidate", e)
+    }
+
+    // Clear listeners map
+    buttonListeners.clear()
+
+    moduleScope.cancel()
+    if (serviceBound) {
+      reactApplicationContext.unbindService(serviceConnection)
+      serviceBound = false
+    }
+  }
+
+  // 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)
+
+      // Check if service is already running
+      if (!ActivityUtil.isServiceRunning(reactApplicationContext, Flic2Service::class.java)) {
+        // Start service
+        ActivityUtil.startForegroundService(reactApplicationContext, 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")
+
+    // Emit started event (matches iOS)
+    emitOnScanStatusChange(Arguments.createMap().apply {
+      putString("event", "started")
+      putString("eventName", "started")
+    })
+
+    manager.startScan(object : Flic2ScanCallback {
+      override fun onDiscoveredAlreadyPairedButton(button: Flic2Button) {
+        Log.d(TAG, "Discovered already paired button")
+      }
+
+      override fun onDiscovered(bdAddr: String) {
+        Log.d(TAG, "Discovered button: $bdAddr")
+      }
+
+      override fun onConnected() {
+        Log.d(TAG, "Button connected during scan")
+      }
+
+      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) {
+          // Auto-connect (trigger mode not available in Android v1.1.0+)
+          button.connect()
+
+          setupButtonListener(button)
+
+          // Update foreground service state after adding button
+          flic2Service?.getManager()?.let { manager ->
+            updateForegroundServiceState(manager.buttons.size)
+          }
+
+          // Emit discovered event as button event (like iOS)
+          emitOnButtonEvent(Arguments.createMap().apply {
+            putString("uuid", button.uuid)
+            putString("event", "discovered")
+            putMap("button", Flic2Converter.buttonToMap(button))
+          })
+        } else {
+          Log.e(TAG, "Scan failed with error code: ${Flic2Converter.scanResultToString(result)}")
+        }
+
+        // Emit scan completion with result code
+        emitOnScanStatusChange(Arguments.createMap().apply {
+          putString("event", "completion")
+          putString("eventName", "completion")
+          putInt("result", mapScanResultToCode(result))
+        })
+      }
+    })
+
+    // Return immediately - scan results will come through events
+    promise.resolve(null)
+  }
+
+  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(null)
+    } 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()
+
+      // Explicitly remove listener from button before forgetting (matches old implementation)
+      val listener = buttonListeners[uuid]
+      if (listener != null) {
+        try {
+          button.removeListener(listener)
+          Log.d(TAG, "Removed listener for button: $uuid")
+        } catch (e: Exception) {
+          Log.w(TAG, "Failed to remove listener for button: $uuid", e)
+        }
+      }
+
+      // Remove listener from map
+      buttonListeners.remove(uuid)
+
+      // Forget button
+      manager.forgetButton(button)
+
+      // Update foreground service state after removing button
+      updateForegroundServiceState(manager.buttons.size)
+
+      promise.resolve(null)
+    } 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(Flic2Converter.buttonToMap(button))
+    } 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(Flic2Converter.buttonToMap(button))
+    } 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(Flic2Converter.buttonToMap(button))
+    } 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(null)
+    } 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(null)
+    } 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 ->
+        // Explicitly remove listener from button before forgetting (matches old implementation)
+        val listener = buttonListeners[button.uuid]
+        if (listener != null) {
+          try {
+            button.removeListener(listener)
+            Log.d(TAG, "Removed listener for button: ${button.uuid}")
+          } catch (e: Exception) {
+            Log.w(TAG, "Failed to remove listener for button: ${button.uuid}", e)
+          }
+        }
+
+        // Remove listener from map
+        buttonListeners.remove(button.uuid)
+
+        // Disconnect before forgetting
+        button.disconnectOrAbortPendingConnection()
+
+        // Forget button
+        manager.forgetButton(button)
+      }
+
+      // Update foreground service state after removing all buttons
+      updateForegroundServiceState(manager.buttons.size)
+
+      promise.resolve(null)
+    } 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
+      }
+
+      promise.resolve(scanJob != null && scanJob?.isActive == true)
+    } 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
+  }
+
+  private fun updateForegroundServiceState(buttonCount: Int) {
+    if (buttonCount > 0) {
+      // Start foreground service when buttons exist
+      flic2Service?.startForegroundService()
+    } else {
+      // Stop foreground service when no buttons
+      flic2Service?.stopForegroundService()
+    }
+  }
+
+  private fun mapScanResultToCode(result: Int): Int {
+    // Map Android library's 9 result codes (0-8) to TypeScript enum codes (0-21) matching iOS
+    // Android library only provides these constants, so we map them to the closest equivalent
+    return when (result) {
+      Flic2ScanCallback.RESULT_SUCCESS -> 0 // SUCCESS
+      Flic2ScanCallback.RESULT_FAILED_ALREADY_RUNNING -> 1 // ALREADY_RUNNING
+      Flic2ScanCallback.RESULT_FAILED_BLUETOOTH_OFF -> 2 // BLUETOOTH_NOT_ACTIVATED
+      Flic2ScanCallback.RESULT_FAILED_SCAN_ERROR -> 3 // UNKNOWN
+      Flic2ScanCallback.RESULT_FAILED_NO_NEW_BUTTONS_FOUND -> 4 // NO_PUBLIC_BUTTON_DISCOVERED
+      Flic2ScanCallback.RESULT_FAILED_BUTTON_ALREADY_CONNECTED_TO_OTHER_DEVICE -> 5 // ALREADY_CONNECTED_TO_ANOTHER_DEVICE
+      Flic2ScanCallback.RESULT_FAILED_CONNECT_TIMED_OUT -> 6 // CONNECTION_TIMEOUT
+      Flic2ScanCallback.RESULT_FAILED_VERIFY_TIMED_OUT -> 7 // INVALID_VERIFIER
+      Flic2ScanCallback.RESULT_SYSTEM_PAIRING_DIALOG_NOT_ACCEPTED -> 9 // BLE_PAIRING_FAILED_USER_CANCELED
+      else -> 3 // UNKNOWN (for any unexpected codes)
+    }
+  }
+}
+

package/android/src/main/java/nl/xguard/flic2/Flic2Package.kt

@@ -0,0 +1,34 @@
+package nl.xguard.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/nl/xguard/flic2/Flic2Service.kt

@@ -0,0 +1,274 @@
+package nl.xguard.flic2
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+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
+    private var isServiceStarted = false
+    private var notification: Notification? = null
+
+    companion object {
+        private const val TAG = "Flic2Service"
+        private const val DEFAULT_NOTIFICATION_ID = 123321
+        private const val DEFAULT_CHANNEL_ID = "Notification_Channel_Flic2Service"
+
+        // Metadata keys for notification configuration
+        private const val KEY_CHANNEL_NAME = "nl.xguard.flic2.notification_channel_name"
+        private const val KEY_CHANNEL_DESCRIPTION = "nl.xguard.flic2.notification_channel_description"
+        private const val NOTIFICATION_TITLE_KEY = "nl.xguard.flic2.notification_title"
+        private const val NOTIFICATION_TEXT_KEY = "nl.xguard.flic2.notification_text"
+        private const val NOTIFICATION_ICON_KEY = "nl.xguard.flic2.notification_icon"
+        private const val NOTIFICATION_ID_KEY = "nl.xguard.flic2.notification_id"
+        private const val CHANNEL_ID_KEY = "nl.xguard.flic2.notification_channel_id"
+    }
+
+    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)
+        }
+
+        // Create notification channel and notification in onCreate
+        createNotificationChannel()
+        notification = createNotification()
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        Log.d(TAG, "Service onStartCommand")
+
+        if (intent != null) {
+            if (Intent.ACTION_BOOT_COMPLETED == intent.action) {
+                Log.d(TAG, "onStartCommand: ACTION_BOOT_COMPLETED")
+            }
+        }
+
+        // Start foreground service if notification is ready
+        if (notification != null) {
+            startForegroundService()
+        }
+
+        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
+
+    fun startForegroundService() {
+        if (!isServiceStarted && notification != null) {
+            isServiceStarted = true
+            try {
+                startForeground(getNotificationId(), notification)
+            } catch (e: Exception) {
+                Log.w(TAG, "startForegroundService() exception", e)
+            }
+        }
+    }
+
+    fun stopForegroundService() {
+        if (isServiceStarted) {
+            isServiceStarted = false
+            stopForeground(true)
+        }
+    }
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                getChannelId(),
+                getChannelName(),
+                NotificationManager.IMPORTANCE_LOW
+            ).apply {
+                description = getChannelDescription()
+                setShowBadge(false)
+            }
+
+            getSystemService(NotificationManager::class.java).createNotificationChannel(channel)
+        }
+    }
+
+    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, getChannelId())
+            .setContentTitle(getNotificationTitle())
+            .setContentText(getNotificationText())
+            .setSmallIcon(getNotificationIcon())
+            .setContentIntent(pendingIntent)
+            .setPriority(NotificationCompat.PRIORITY_LOW)
+            .setOngoing(true)
+            .build()
+    }
+
+    private fun getNotificationId(): Int {
+        return try {
+            val metadata = applicationContext.packageManager
+                .getApplicationInfo(applicationContext.packageName, PackageManager.GET_META_DATA)
+                .metaData
+            metadata?.getInt(NOTIFICATION_ID_KEY, DEFAULT_NOTIFICATION_ID) ?: DEFAULT_NOTIFICATION_ID
+        } catch (e: PackageManager.NameNotFoundException) {
+            Log.w(TAG, "getNotificationId() NameNotFoundException", e)
+            DEFAULT_NOTIFICATION_ID
+        } catch (e: Exception) {
+            Log.w(TAG, "getNotificationId() exception", e)
+            DEFAULT_NOTIFICATION_ID
+        }
+    }
+
+    private fun getChannelId(): String {
+        return try {
+            val metadata = applicationContext.packageManager
+                .getApplicationInfo(applicationContext.packageName, PackageManager.GET_META_DATA)
+                .metaData
+            metadata?.getString(CHANNEL_ID_KEY) ?: DEFAULT_CHANNEL_ID
+        } catch (e: PackageManager.NameNotFoundException) {
+            Log.w(TAG, "getChannelId() NameNotFoundException", e)
+            DEFAULT_CHANNEL_ID
+        } catch (e: Exception) {
+            Log.w(TAG, "getChannelId() exception", e)
+            DEFAULT_CHANNEL_ID
+        }
+    }
+
+    private fun getChannelName(): String {
+        return try {
+            val metadata = applicationContext.packageManager
+                .getApplicationInfo(applicationContext.packageName, PackageManager.GET_META_DATA)
+                .metaData
+            metadata?.getString(KEY_CHANNEL_NAME) ?: "Flic2Channel"
+        } catch (e: PackageManager.NameNotFoundException) {
+            Log.w(TAG, "getChannelName() NameNotFoundException", e)
+            "Flic2Channel"
+        } catch (e: Exception) {
+            Log.w(TAG, "getChannelName() exception", e)
+            "Flic2Channel"
+        }
+    }
+
+    private fun getChannelDescription(): String {
+        return try {
+            val metadata = applicationContext.packageManager
+                .getApplicationInfo(applicationContext.packageName, PackageManager.GET_META_DATA)
+                .metaData
+            metadata?.getString(KEY_CHANNEL_DESCRIPTION) ?: "Flic2Channel"
+        } catch (e: PackageManager.NameNotFoundException) {
+            Log.w(TAG, "getChannelDescription() NameNotFoundException", e)
+            "Flic2Channel"
+        } catch (e: Exception) {
+            Log.w(TAG, "getChannelDescription() exception", e)
+            "Flic2Channel"
+        }
+    }
+
+    private fun getNotificationTitle(): String {
+        return try {
+            val metadata = applicationContext.packageManager
+                .getApplicationInfo(applicationContext.packageName, PackageManager.GET_META_DATA)
+                .metaData
+            metadata?.getString(NOTIFICATION_TITLE_KEY) ?: "Flic 2"
+        } catch (e: PackageManager.NameNotFoundException) {
+            Log.w(TAG, "getNotificationTitle() NameNotFoundException", e)
+            "Flic 2"
+        } catch (e: Exception) {
+            Log.w(TAG, "getNotificationTitle() exception", e)
+            "Flic 2"
+        }
+    }
+
+    private fun getNotificationText(): String {
+        return try {
+            val metadata = applicationContext.packageManager
+                .getApplicationInfo(applicationContext.packageName, PackageManager.GET_META_DATA)
+                .metaData
+            metadata?.getString(NOTIFICATION_TEXT_KEY) ?: "Flic 2 service is running"
+        } catch (e: PackageManager.NameNotFoundException) {
+            Log.w(TAG, "getNotificationText() NameNotFoundException", e)
+            "Flic 2 service is running"
+        } catch (e: Exception) {
+            Log.w(TAG, "getNotificationText() exception", e)
+            "Flic 2 service is running"
+        }
+    }
+
+    private fun getNotificationIcon(): Int {
+        return try {
+            val metadata = applicationContext.packageManager
+                .getApplicationInfo(applicationContext.packageName, PackageManager.GET_META_DATA)
+                .metaData
+            val icon = metadata?.getInt(NOTIFICATION_ICON_KEY, 0) ?: 0
+            if (icon != 0) icon else android.R.drawable.ic_dialog_info
+        } catch (e: PackageManager.NameNotFoundException) {
+            Log.w(TAG, "getNotificationIcon() NameNotFoundException", e)
+            android.R.drawable.ic_dialog_info
+        } catch (e: Exception) {
+            Log.w(TAG, "getNotificationIcon() exception", e)
+            android.R.drawable.ic_dialog_info
+        }
+    }
+
+    // BootUpReceiver for handling device boot
+    class BootUpReceiver : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            Log.d(TAG, "BootUpReceiver()")
+            // The Application class's onCreate has already been called at this point, which is what we want
+        }
+    }
+
+    // UpdateReceiver for handling app updates
+    class UpdateReceiver : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            Log.d(TAG, "UpdateReceiver()")
+            // The Application class's onCreate has already been called at this point, which is what we want
+        }
+    }
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-flic2",
-  "version": "2.0.0-beta.11",
+  "version": "2.0.0-beta.12",
   "description": "React Native Flic plugin made with the Flic2 SDK (unofficial)",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",