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

package/android/build.gradle

@@ -26,7 +26,7 @@ def getExtOrIntegerDefault(name) {
 }
 
 android {
-  namespace "com.flic2"
+  namespace "nl.xguard.flic2"
 
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 

package/android/src/main/AndroidManifest.xml

@@ -15,6 +15,7 @@
     <!-- 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
@@ -22,6 +23,28 @@
             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/{com → nl/xguard}/flic2/Flic2ButtonListener.kt

@@ -1,4 +1,4 @@
-package com.flic2
+package nl.xguard.flic2
 
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
@@ -47,10 +47,20 @@ class Flic2ButtonEventListener(
         val event = if (isDown) "buttonDown" else "buttonUp"
         emitEvent(createButtonEvent(button, event).apply {
             putBoolean("queued", wasQueued)
-            putDouble("age", System.currentTimeMillis() - timestamp.toDouble())
+            // 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,
@@ -59,13 +69,11 @@ class Flic2ButtonEventListener(
         isClick: Boolean,
         isHold: Boolean
     ) {
-        val event = if (isClick) "click" else "hold"
-        emitEvent(createButtonEvent(button, event).apply {
-            putBoolean("queued", wasQueued)
-            putDouble("age", System.currentTimeMillis() - timestamp.toDouble())
-        })
+        // 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,
@@ -74,11 +82,7 @@ class Flic2ButtonEventListener(
         isSingleClick: Boolean,
         isDoubleClick: Boolean
     ) {
-        val event = if (isSingleClick) "click" else "doubleClick"
-        emitEvent(createButtonEvent(button, event).apply {
-            putBoolean("queued", wasQueued)
-            putDouble("age", System.currentTimeMillis() - timestamp.toDouble())
-        })
+        // Intentionally empty - events are handled by onButtonSingleOrDoubleClickOrHold
     }
 
     override fun onButtonSingleOrDoubleClickOrHold(
@@ -98,7 +102,15 @@ class Flic2ButtonEventListener(
         }
         emitEvent(createButtonEvent(button, event).apply {
             putBoolean("queued", wasQueued)
-            putDouble("age", System.currentTimeMillis() - timestamp.toDouble())
+            // 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)
         })
     }
 

package/android/src/main/java/{com → nl/xguard}/flic2/Flic2Converter.kt

@@ -1,4 +1,4 @@
-package com.flic2
+package nl.xguard.flic2
 
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableArray
@@ -31,8 +31,7 @@ object Flic2Converter {
             putInt("firmwareRevision", button.getFirmwareVersion())
 
             // Check if ready by comparing connection state
-            val isReady = connState == Flic2Button.CONNECTION_STATE_CONNECTED_READY
-            putBoolean("isReady", isReady)
+            putBoolean("isReady", connState == Flic2Button.CONNECTION_STATE_CONNECTED_READY)
 
             // Get battery level from BatteryLevel object
             val batteryLevel = button.getLastKnownBatteryLevel()

package/android/src/main/java/{com → nl/xguard}/flic2/Flic2Module.kt

@@ -1,4 +1,4 @@
-package com.flic2
+package nl.xguard.flic2
 
 import android.content.ComponentName
 import android.content.Context
@@ -48,8 +48,7 @@ class Flic2Module(reactContext: ReactApplicationContext) :
   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()
+      flic2Service = (service as Flic2Service.Flic2ServiceBinder).getService()
       serviceBound = true
 
       // Set up listeners for existing buttons
@@ -57,14 +56,13 @@ class Flic2Module(reactContext: ReactApplicationContext) :
         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(Arguments.createMap().apply {
-          putBoolean("success", true)
-          putString("message", "Manager initialized successfully")
-        })
+        promise.resolve(null)
         initializePromise = null
       }
     }
@@ -88,6 +86,31 @@ class Flic2Module(reactContext: ReactApplicationContext) :
 
   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)
@@ -95,20 +118,6 @@ class Flic2Module(reactContext: ReactApplicationContext) :
     }
   }
 
-  // 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) {
@@ -118,11 +127,10 @@ class Flic2Module(reactContext: ReactApplicationContext) :
 
       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)
+      // 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
@@ -172,63 +180,60 @@ class Flic2Module(reactContext: ReactApplicationContext) :
 
     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")
-        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
+          // 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 {
-          val errorCode = Flic2Converter.scanResultToString(result)
-          Log.e(TAG, "Scan failed with error code: $errorCode")
+          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(Arguments.createMap().apply {
-      putBoolean("success", true)
-      putString("message", "Scan started")
-    })
+    promise.resolve(null)
   }
 
   override fun stopScan(promise: Promise) {
@@ -242,10 +247,7 @@ class Flic2Module(reactContext: ReactApplicationContext) :
       scanJob?.cancel()
       manager.stopScan()
 
-      promise.resolve(Arguments.createMap().apply {
-        putBoolean("success", true)
-        putString("message", "Scan stopped")
-      })
+      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)
@@ -269,16 +271,27 @@ class Flic2Module(reactContext: ReactApplicationContext) :
       // Disconnect before forgetting like iOS
       button.disconnectOrAbortPendingConnection()
 
-      // Remove listener
+      // 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)
 
-      promise.resolve(Arguments.createMap().apply {
-        putBoolean("success", true)
-        putString("message", "Button forgotten")
-      })
+      // 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)
@@ -297,10 +310,7 @@ class Flic2Module(reactContext: ReactApplicationContext) :
 
       button.connect()
 
-      promise.resolve(Arguments.createMap().apply {
-        putBoolean("success", true)
-        putString("message", "Connection initiated")
-      })
+      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)
@@ -317,10 +327,7 @@ class Flic2Module(reactContext: ReactApplicationContext) :
 
       button.disconnectOrAbortPendingConnection()
 
-      promise.resolve(Arguments.createMap().apply {
-        putBoolean("success", true)
-        putString("message", "Disconnection initiated")
-      })
+      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)
@@ -352,10 +359,7 @@ class Flic2Module(reactContext: ReactApplicationContext) :
       // v1.1.0 uses setName() method instead of property
       button.setName(nickname)
 
-      promise.resolve(Arguments.createMap().apply {
-        putBoolean("success", true)
-        putString("message", "Nickname set")
-      })
+      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)
@@ -378,10 +382,7 @@ class Flic2Module(reactContext: ReactApplicationContext) :
         button.connect()
       }
 
-      promise.resolve(Arguments.createMap().apply {
-        putBoolean("success", true)
-        putString("message", "All buttons connection initiated")
-      })
+      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)
@@ -403,10 +404,7 @@ class Flic2Module(reactContext: ReactApplicationContext) :
         button.disconnectOrAbortPendingConnection()
       }
 
-      promise.resolve(Arguments.createMap().apply {
-        putBoolean("success", true)
-        putString("message", "All buttons disconnection initiated")
-      })
+      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)
@@ -425,15 +423,31 @@ class Flic2Module(reactContext: ReactApplicationContext) :
       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)
       }
 
-      promise.resolve(Arguments.createMap().apply {
-        putBoolean("success", true)
-        putString("message", "All buttons forgotten")
-      })
+      // 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)
@@ -448,8 +462,7 @@ class Flic2Module(reactContext: ReactApplicationContext) :
         return
       }
 
-      val scanning = (scanJob != null && scanJob?.isActive == true)
-      promise.resolve(scanning)
+      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)
@@ -477,4 +490,32 @@ class Flic2Module(reactContext: ReactApplicationContext) :
     // 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/{com → nl/xguard}/flic2/Flic2Package.kt

@@ -1,4 +1,4 @@
-package com.flic2
+package nl.xguard.flic2
 
 import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
@@ -31,3 +31,4 @@ class Flic2Package : BaseReactPackage() {
     }
   }
 }
+