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

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/com/flic2/ActivityUtil.kt

@@ -0,0 +1,29 @@
+package com.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/flic2/Flic2ButtonListener.kt

@@ -51,6 +51,8 @@ class Flic2ButtonEventListener(
         })
     }
 
+    // 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 +61,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 +74,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(

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

@@ -57,6 +57,8 @@ 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
@@ -95,20 +97,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 +106,11 @@ 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
+      val isRunning = ActivityUtil.isServiceRunning(reactApplicationContext, Flic2Service::class.java)
+      if (!isRunning) {
+        // Start service
+        ActivityUtil.startForegroundService(reactApplicationContext, intent)
       }
 
       // Bind to service - promise will be resolved in onServiceConnected
@@ -172,46 +160,42 @@ 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")
-          })
+        val resultCode = mapScanResultToCode(result)
 
+        if (result == Flic2ScanCallback.RESULT_SUCCESS && button != null) {
           // 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")
@@ -221,6 +205,13 @@ class Flic2Module(reactContext: ReactApplicationContext) :
           val errorCode = Flic2Converter.scanResultToString(result)
           Log.e(TAG, "Scan failed with error code: $errorCode")
         }
+
+        // Emit scan completion with result code
+        emitOnScanStatusChange(Arguments.createMap().apply {
+          putString("event", "completion")
+          putString("eventName", "completion")
+          putInt("result", resultCode)
+        })
       }
     })
 
@@ -275,6 +266,9 @@ class Flic2Module(reactContext: ReactApplicationContext) :
       // Forget button
       manager.forgetButton(button)
 
+      // Update foreground service state after removing button
+      updateForegroundServiceState(manager.buttons.size)
+
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", true)
         putString("message", "Button forgotten")
@@ -430,6 +424,9 @@ class Flic2Module(reactContext: ReactApplicationContext) :
         manager.forgetButton(button)
       }
 
+      // Update foreground service state after removing all buttons
+      updateForegroundServiceState(manager.buttons.size)
+
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", true)
         putString("message", "All buttons forgotten")
@@ -477,4 +474,31 @@ 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/flic2/Flic2Service.kt

@@ -5,7 +5,10 @@ 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
@@ -19,12 +22,22 @@ 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 NOTIFICATION_ID = 1
-        private const val CHANNEL_ID = "Flic2ServiceChannel"
-        private const val CHANNEL_NAME = "Flic2 Service"
+        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() {
@@ -47,31 +60,25 @@ class Flic2Service : Service() {
         } 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")
 
-        // 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)
+        if (intent != null) {
+            if (Intent.ACTION_BOOT_COMPLETED == intent.action) {
+                Log.d(TAG, "onStartCommand: ACTION_BOOT_COMPLETED")
             }
-
-            val notificationManager = getSystemService(NotificationManager::class.java)
-            notificationManager.createNotificationChannel(channel)
         }
 
-        // Create notification
-        val notification = createNotification()
-
-        // Start as foreground service
-        startForeground(NOTIFICATION_ID, notification)
+        // Start foreground service if notification is ready
+        if (notification != null) {
+            startForegroundService()
+        }
 
         return START_STICKY
     }
@@ -90,6 +97,45 @@ class Flic2Service : Service() {
 
     fun isManagerInitialized(): Boolean = manager != null
 
+    fun startForegroundService() {
+        if (!isServiceStarted && notification != null) {
+            isServiceStarted = true
+            try {
+                val notificationId = getNotificationId()
+                startForeground(notificationId, 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 channelId = getChannelId()
+            val channelName = getChannelName()
+            val channelDescription = getChannelDescription()
+
+            val channel = NotificationChannel(
+                channelId,
+                channelName,
+                NotificationManager.IMPORTANCE_LOW
+            ).apply {
+                description = channelDescription
+                setShowBadge(false)
+            }
+
+            val notificationManager = getSystemService(NotificationManager::class.java)
+            notificationManager.createNotificationChannel(channel)
+        }
+    }
+
     private fun createNotification(): Notification {
         val notificationIntent = Intent(this, Flic2Service::class.java)
         val pendingIntent = PendingIntent.getActivity(
@@ -99,14 +145,141 @@ class Flic2Service : Service() {
             PendingIntent.FLAG_IMMUTABLE
         )
 
-        return NotificationCompat.Builder(this, CHANNEL_ID)
-            .setContentTitle("Flic2 Service")
-            .setContentText("Flic2 buttons are connected")
-            .setSmallIcon(android.R.drawable.ic_dialog_info)
+        val channelId = getChannelId()
+        val title = getNotificationTitle()
+        val text = getNotificationText()
+        val icon = getNotificationIcon()
+
+        return NotificationCompat.Builder(this, channelId)
+            .setContentTitle(title)
+            .setContentText(text)
+            .setSmallIcon(icon)
             .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/ios/Flic2.h

@@ -6,7 +6,6 @@
 
 @interface Flic2 : NativeFlic2SpecBase <NativeFlic2Spec, FLICManagerDelegate, FLICButtonDelegate>
 
-@property (nonatomic, strong) FLICManager *manager;
 @property (nonatomic, assign) BOOL managerRestored;
 
 @end