expo-flic2 0.3.1 → 0.3.2

package/android/build.gradle

@@ -4,14 +4,14 @@ plugins {
 }
 
 group = 'expo.modules.flic2'
-version = '0.3.1'
+version = '0.3.2'
 
 android {
   namespace "expo.modules.flic2"
 
   defaultConfig {
     versionCode 1
-    versionName "0.3.1"
+    versionName "0.3.2"
     minSdkVersion 24
   }
 
@@ -32,4 +32,5 @@ repositories {
 
 dependencies {
   implementation 'com.github.50ButtonsEach:flic2lib-android:2.0.1'
+  testImplementation 'junit:junit:4.13.2'
 }

package/android/src/main/java/expo/modules/flic2/AgeCalculator.kt

@@ -0,0 +1,28 @@
+package expo.modules.flic2
+
+/**
+ * Translates a Flic2 button event timestamp into an age (ms since the physical press).
+ *
+ * The Flic2 SDK provides timestamps in milliseconds since the *button's own boot*, which is
+ * unrelated to Android's clocks. To convert, we establish a correlation at onReady time:
+ * we record both the button's readyTimestamp and Android's SystemClock.elapsedRealtime()
+ * at the same moment, then use that offset for all subsequent events.
+ */
+object AgeCalculator {
+    /**
+     * @param nowElapsedMs          SystemClock.elapsedRealtime() at the moment of processing
+     * @param androidReadyElapsedMs SystemClock.elapsedRealtime() recorded when onReady fired
+     * @param buttonReadyTimestamp  button's readyTimestamp (ms since button boot) from onReady
+     * @param eventTimestamp        button's event timestamp (ms since button boot)
+     * @return age in milliseconds, clamped to 0 (never negative)
+     */
+    fun computeAgeMs(
+        nowElapsedMs: Long,
+        androidReadyElapsedMs: Long,
+        buttonReadyTimestamp: Long,
+        eventTimestamp: Long
+    ): Long {
+        val estimatedAndroidEventTime = androidReadyElapsedMs + (eventTimestamp - buttonReadyTimestamp)
+        return maxOf(0L, nowElapsedMs - estimatedAndroidEventTime)
+    }
+}

package/android/src/main/java/expo/modules/flic2/ExpoFlic2Module.kt

@@ -17,6 +17,9 @@ class ExpoFlic2Module : Module() {
   private var manager: Flic2Manager? = null
   private val triggerModes = ConcurrentHashMap<String, String>()
   private val buttonListeners = mutableMapOf<String, Flic2ButtonListener>()
+  // Correlation between button clock and Android clock, established at onReady.
+  // Maps uuid -> Pair(androidReadyElapsedMs, buttonReadyTimestampMs)
+  private val readyCorrelations = ConcurrentHashMap<String, Pair<Long, Long>>()
 
   override fun definition() = ModuleDefinition {
     Name("ExpoFlic2")
@@ -38,6 +41,7 @@ class ExpoFlic2Module : Module() {
       }
       buttonListeners.clear()
       triggerModes.clear()
+      readyCorrelations.clear()
     }
 
     Function("initialize") {
@@ -115,6 +119,11 @@ class ExpoFlic2Module : Module() {
     }
   }
 
+  private fun ageMs(uuid: String, eventTimestamp: Long): Long {
+    val (androidReadyMs, buttonReadyMs) = readyCorrelations[uuid] ?: return 0L
+    return AgeCalculator.computeAgeMs(SystemClock.elapsedRealtime(), androidReadyMs, buttonReadyMs, eventTimestamp)
+  }
+
   private fun findButton(uuid: String): Flic2Button? {
     return manager?.getButtons()?.find { it.uuid == uuid }
   }
@@ -138,12 +147,12 @@ class ExpoFlic2Module : Module() {
       ) {
         val mode = triggerModes[button.uuid] ?: "clickAndDoubleClickAndHold"
         if (mode != "click" && mode != "clickAndHold") return
-        val ageSeconds = (SystemClock.elapsedRealtime() - timestamp) / 1000
+        val age = ageMs(button.uuid, timestamp)
         if (isClick) {
-          sendEvent("onFlic2Click", mapOf("uuid" to button.uuid, "queued" to wasQueued, "age" to ageSeconds))
+          sendEvent("onFlic2Click", mapOf("uuid" to button.uuid, "queued" to wasQueued, "age" to age))
         }
         if (isHold && mode == "clickAndHold") {
-          sendEvent("onFlic2Hold", mapOf("uuid" to button.uuid, "queued" to wasQueued, "age" to ageSeconds))
+          sendEvent("onFlic2Hold", mapOf("uuid" to button.uuid, "queued" to wasQueued, "age" to age))
         }
       }
 
@@ -158,7 +167,7 @@ class ExpoFlic2Module : Module() {
       ) {
         val mode = triggerModes[button.uuid] ?: "clickAndDoubleClickAndHold"
         if (mode == "click" || mode == "clickAndHold") return
-        val ageSeconds = (SystemClock.elapsedRealtime() - timestamp) / 1000
+        val age = ageMs(button.uuid, timestamp)
         val emitClick = isSingleClick && mode != "clickAndDoubleClick"
         val emitDoubleClick = isDoubleClick
         val emitHold = isHold && mode != "clickAndDoubleClick"
@@ -166,21 +175,21 @@ class ExpoFlic2Module : Module() {
           sendEvent("onFlic2Click", mapOf(
             "uuid" to button.uuid,
             "queued" to wasQueued,
-            "age" to ageSeconds
+            "age" to age
           ))
         }
         if (emitDoubleClick) {
           sendEvent("onFlic2DoubleClick", mapOf(
             "uuid" to button.uuid,
             "queued" to wasQueued,
-            "age" to ageSeconds
+            "age" to age
           ))
         }
         if (emitHold) {
           sendEvent("onFlic2Hold", mapOf(
             "uuid" to button.uuid,
             "queued" to wasQueued,
-            "age" to ageSeconds
+            "age" to age
           ))
         }
       }
@@ -197,7 +206,7 @@ class ExpoFlic2Module : Module() {
           "uuid" to button.uuid,
           "isDown" to isDown,
           "queued" to wasQueued,
-          "age" to ((SystemClock.elapsedRealtime() - timestamp) / 1000)
+          "age" to ageMs(button.uuid, timestamp)
         ))
       }
 
@@ -209,6 +218,7 @@ class ExpoFlic2Module : Module() {
       }
 
       override fun onReady(button: Flic2Button, timestamp: Long) {
+        readyCorrelations[button.uuid] = Pair(SystemClock.elapsedRealtime(), timestamp)
         sendEvent("onFlic2Connection", mapOf(
           "uuid" to button.uuid,
           "state" to "ready"

package/android/src/test/java/expo/modules/flic2/AgeCalculatorTest.kt

@@ -0,0 +1,68 @@
+package expo.modules.flic2
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class AgeCalculatorTest {
+
+    // Scenario: button has been running for 10_000ms since its own boot.
+    // Android has been running for 5_000ms since its own boot.
+    // onReady fired when button reported 10_000ms and Android was at 5_000ms.
+
+    private val androidReady = 5_000L
+    private val buttonReady = 10_000L
+
+    @Test
+    fun `fresh press arrives with near-zero latency`() {
+        // Button pressed at button-time 10_050ms (50ms after ready).
+        // Android receives the event at android-time 5_080ms (80ms after ready).
+        // Expected age = 80 - 50 = 30ms.
+        val age = AgeCalculator.computeAgeMs(
+            nowElapsedMs = 5_080L,
+            androidReadyElapsedMs = androidReady,
+            buttonReadyTimestamp = buttonReady,
+            eventTimestamp = 10_050L
+        )
+        assertEquals(30L, age)
+    }
+
+    @Test
+    fun `queued press that happened 5 seconds before button connected`() {
+        // Button pressed at button-time 5_000ms (5_000ms before ready at 10_000ms).
+        // Android receives at android-time 5_100ms (100ms after ready).
+        // Expected age = 5_100 - (5_000 + (5_000 - 10_000)) = 5_100 - 0 = 5_100ms.
+        val age = AgeCalculator.computeAgeMs(
+            nowElapsedMs = 5_100L,
+            androidReadyElapsedMs = androidReady,
+            buttonReadyTimestamp = buttonReady,
+            eventTimestamp = 5_000L
+        )
+        assertEquals(5_100L, age)
+    }
+
+    @Test
+    fun `age is clamped to zero when button clock is slightly ahead of android clock`() {
+        // eventTimestamp slightly ahead of ready (clock drift), should not go negative.
+        val age = AgeCalculator.computeAgeMs(
+            nowElapsedMs = 5_000L,
+            androidReadyElapsedMs = androidReady,
+            buttonReadyTimestamp = buttonReady,
+            eventTimestamp = 10_020L  // 20ms into the future relative to now
+        )
+        assertEquals(0L, age)
+    }
+
+    @Test
+    fun `age is zero when event happens exactly now`() {
+        // Button pressed at button-time 10_200ms (200ms after ready).
+        // Android receives at android-time 5_200ms (200ms after ready).
+        // Perfectly synchronised clocks => age = 0.
+        val age = AgeCalculator.computeAgeMs(
+            nowElapsedMs = 5_200L,
+            androidReadyElapsedMs = androidReady,
+            buttonReadyTimestamp = buttonReady,
+            eventTimestamp = 10_200L
+        )
+        assertEquals(0L, age)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-flic2",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Expo module for Flic2 Bluetooth buttons",
   "main": "build/index.js",
   "types": "build/index.d.ts",