Sync Eversense plugin to latest from AndroidAPSEversenseCoexist

Full sync of all Eversense-related code:
- Complete eversense module: build.gradle.kts, manifest, proguard, all
  source files (callbacks, enums, models, e3/e365 packets, utils, crypto)
- E365 cloud upload: EversenseHttp365Util with token management,
  uploadGlucoseReadings (base64 EssentialLog, bare JSON array body)
- BLE reconnect exponential backoff: 5s→10s→20s→40s→60s cap for GATT
  errors; 30s for status-19 (transmitter rejection); 5s for clean disconnect
- EversensePlugin: cloud upload toggle, toast notifications, E3/E365
  section visibility gating, duplicate watcher registration fix
- Unit tests: EversenseHttp365UtilTest (13 tests via MockWebServer),
  CalibrationPacketTest (29 tests)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: CAPTCG

plugins/eversense/.gitignore

@@ -0,0 +1 @@
+/build

plugins/eversense/build.gradle.kts

@@ -1,19 +1,28 @@
 plugins {
     alias(libs.plugins.android.library)
     alias(libs.plugins.ksp)
+
+    id("kotlin-android")
     id("kotlinx-serialization")
     id("android-module-dependencies")
     id("test-module-dependencies")
 }
+
 android {
     namespace = "com.nightscout.eversense"
 }
+
 dependencies {
     api(libs.androidx.core)
-    api(platform(libs.kotlinx.serialization.bom))
     api(libs.kotlinx.serialization.json)
+
     api(libs.org.slf4j.api)
     api(libs.com.github.tony19.logback.android)
+
     implementation("org.bouncycastle:bcpkix-jdk18on:1.81")
     implementation("org.bouncycastle:bcprov-jdk18on:1.81")
+
+    testImplementation("com.squareup.okhttp3:mockwebserver:4.12.0")
 }
+
+

plugins/eversense/consumer-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

plugins/eversense/proguard-rules.pro

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
+    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+    <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
+
+    <application>
+    </application>
+
+</manifest>

plugins/eversense/src/main/AndroidManifest.xml

@@ -46,13 +46,7 @@ class EversenseCGMPlugin {
         gattCallback = EversenseGattCallback(this, preference)
     }
 
-    // FIX 3: setSmoothing now returns Boolean and logs on failure.
-    fun setCoexistenceMode(enabled: Boolean) {
-        gattCallback?.coexistenceMode = enabled
-        EversenseLogger.info(TAG, "Coexistence mode: $enabled")
-    }
-
-        fun setSmoothing(value: Boolean): Boolean {
+    fun setSmoothing(value: Boolean): Boolean {
         val state = getCurrentState() ?: run {
             EversenseLogger.error(TAG, "Cannot set smoothing: current state is null. Has setContext been called?")
             return false
@@ -73,6 +67,7 @@ class EversenseCGMPlugin {
     }
 
     fun isConnected(): Boolean = gattCallback?.isConnected() ?: false
+    fun is365(): Boolean = gattCallback?.is365() ?: false
 
     fun getCurrentState(): EversenseState? {
         val preferences = preferences ?: run {

plugins/eversense/src/main/kotlin/com/nightscout/eversense/EversenseCGMPlugin.kt

@@ -51,6 +51,7 @@ class EversenseGattCallback(
         private const val magicDescriptorUUID = "00002902-0000-1000-8000-00805f9b34fb"
 
         private const val WRITE_TIMEOUT_MS = 5000L
+        private const val CALIBRATION_TIMEOUT_MS = 15000L
     }
 
     // FIX 1: Dedicated BLE executor for callbacks; separate network executor for HTTP calls
@@ -77,19 +78,17 @@ class EversenseGattCallback(
     @Volatile
     private var connected: Boolean = false
 
-    // Tracks consecutive failed connection attempts to detect transmitter placement issues
+    // Tracks consecutive status-19 failures to detect transmitter placement issues
     @Volatile
     private var failedConnectionAttempts: Int = 0
     private val PLACEMENT_WARNING_THRESHOLD = 3
 
-    // When true, AAPS disconnects after each sync to give the official Eversense app
-    // a 2-minute window to connect and upload data to the cloud. Reconnects automatically.
+    // Tracks consecutive general reconnect attempts (reset on successful connection).
+    // Used to compute exponential backoff so AAPS retries quickly after boot (when the
+    // official Eversense app temporarily holds the BLE connection) and backs off for
+    // sustained failures to avoid draining the battery.
     @Volatile
-    var coexistenceMode: Boolean = false
-
-    // True during a planned coexistence disconnect — suppresses normal auto-reconnect
-    @Volatile
-    private var plannedDisconnect: Boolean = false
+    private var reconnectAttempts: Int = 0
 
     fun isConnected(): Boolean = connected
     fun is365(): Boolean = security == EversenseSecurityType.SecureV2
@@ -135,6 +134,9 @@ class EversenseGattCallback(
             bluetoothGatt = gatt
             // FIX 3: Set connected flag on confirmed STATE_CONNECTED.
             connected = true
+            // Reset backoff counters on successful connection
+            reconnectAttempts = 0
+            failedConnectionAttempts = 0
 
             preferences.edit(commit = true) {
                 putString(StorageKeys.REMOTE_DEVICE_KEY, gatt.device.address)
@@ -147,7 +149,9 @@ class EversenseGattCallback(
             }
 
             if (!gatt.requestMtu(512)) {
-                EversenseLogger.error(TAG, "Failed to request MTU")
+                EversenseLogger.warning(TAG, "requestMtu returned false — skipping to discoverServices with default payload size")
+                payloadSize = 20
+                gatt.discoverServices()
             }
             return
         }
@@ -173,15 +177,33 @@ class EversenseGattCallback(
             }
 
             val storedAddress = preferences.getString(StorageKeys.REMOTE_DEVICE_KEY, null)
-            if (storedAddress != null && !plannedDisconnect) {
-                val delayMs = if (status == BluetoothGatt.GATT_SUCCESS) 5000L else 10000L
-                EversenseLogger.info(TAG, "Scheduling auto-reconnect in ${delayMs/1000}s (status: $status)")
+            if (storedAddress != null) {
+                // Exponential backoff so AAPS reclaims the transmitter quickly after boot
+                // (when the official Eversense app temporarily holds the BLE connection)
+                // and avoids battery drain during sustained unavailability.
+                //
+                // Status 19 = transmitter actively rejected us (placement issue, not competition) —
+                // use a fixed 30 s interval so we don't spam it.
+                // Status GATT_SUCCESS = clean disconnect (we or the transmitter closed cleanly) —
+                // reconnect quickly in 5 s.
+                // All other status codes (e.g. 133 = GATT_ERROR, device busy) = backoff:
+                //   attempt 0 → 5 s, attempt 1 → 10 s, attempt 2 → 20 s, attempt 3 → 40 s,
+                //   attempt 4+ → 60 s cap.
+                val delayMs: Long = when {
+                    status == 19 -> 30_000L
+                    status == BluetoothGatt.GATT_SUCCESS -> 5_000L
+                    else -> {
+                        val attempt = reconnectAttempts++
+                        minOf(5_000L * (1L shl minOf(attempt, 4)), 60_000L)
+                    }
+                }
+                EversenseLogger.info(TAG, "Scheduling auto-reconnect in ${delayMs / 1000}s (status: $status, attempt: $reconnectAttempts)")
                 handler.postDelayed({
-                    EversenseLogger.info(TAG, "Attempting auto-reconnect...")
+                    EversenseLogger.info(TAG, "Attempting auto-reconnect (attempt $reconnectAttempts)...")
                     plugin.connect(null)
                 }, delayMs)
             } else {
-                if (!plannedDisconnect) { EversenseLogger.warning(TAG, "No stored device address — skipping auto-reconnect") } else { EversenseLogger.info(TAG, "Planned coexistence disconnect — suppressing auto-reconnect") }
+                EversenseLogger.warning(TAG, "No stored device address — skipping auto-reconnect")
             }
         }
     }
@@ -318,16 +340,6 @@ class EversenseGattCallback(
             bleExecutor.submit {
                 EversenseE3Communicator.readGlucose(this, preferences, plugin.watchers)
                 EversenseE3Communicator.fullSync(this, preferences, plugin.watchers)
-                    if (coexistenceMode) {
-                        EversenseLogger.info(TAG, "Coexistence — disconnecting to give official app 2-minute window")
-                        plannedDisconnect = true
-                        disconnect()
-                        handler.postDelayed({
-                            EversenseLogger.info(TAG, "Coexistence reconnect — official app window ended")
-                            plannedDisconnect = false
-                            plugin.connect(null)
-                        }, 120000L)
-                    }
             }
             return
         }
@@ -345,16 +357,6 @@ class EversenseGattCallback(
                     Eversense365Communicator.readGlucose(this, preferences, plugin.watchers)
                     Eversense365Communicator.fullSync(this, preferences, plugin.watchers)
                 }
-                if (coexistenceMode && !plannedDisconnect) {
-                    EversenseLogger.info(TAG, "Coexistence — disconnecting to give official app 2-minute window")
-                    plannedDisconnect = true
-                    disconnect()
-                    handler.postDelayed({
-                        EversenseLogger.info(TAG, "Coexistence reconnect — official app window ended")
-                        plannedDisconnect = false
-                        plugin.connect(null)
-                    }, 120000L)
-                }
             }
             return
         } else if (data.size >= 4 && data[0] == Eversense365Packets.NotificationResponseId && data[1] == 0x03.toByte()) {
@@ -389,12 +391,13 @@ class EversenseGattCallback(
 
             if (EversenseE3Packets.isErrorPacket(data[0])) {
                 EversenseLogger.error(TAG, "Received error response - data: ${data.toHexString()}")
+                packet.isErrorResponse = true
                 packet.notifyAll()
                 return
             }
 
             if (security == EversenseSecurityType.None) {
-                if (packetAnnotation.responseId != data[0]) {
+                if (!packet.skipResponseIdValidation && packetAnnotation.responseId != data[0]) {
                     EversenseLogger.warning(TAG, "Incorrect responseId - expected: ${packetAnnotation.responseId}, got: ${data[0]}")
                     return
                 }
@@ -419,7 +422,7 @@ class EversenseGattCallback(
     @SuppressLint("MissingPermission")
     @OptIn(ExperimentalStdlibApi::class)
     @Throws(EversenseWriteException::class)
-    fun <T : EversenseBasePacket.Response> writePacket(packet: EversenseBasePacket): T {
+    fun <T : EversenseBasePacket.Response> writePacket(packet: EversenseBasePacket, timeoutMs: Long = WRITE_TIMEOUT_MS): T {
         val gatt = bluetoothGatt ?: throw EversenseWriteException("Gatt is null — not connected")
 
         val requestCharacteristic = requestCharacteristic
@@ -441,11 +444,14 @@ class EversenseGattCallback(
                 // Previously, a timeout would fall through to parseResponse() silently, likely
                 // producing a confusing cast exception rather than a clear timeout error.
                 val start = System.currentTimeMillis()
-                packet.wait(WRITE_TIMEOUT_MS)
+                packet.wait(timeoutMs)
                 val elapsed = System.currentTimeMillis() - start
-                if (elapsed >= WRITE_TIMEOUT_MS) {
+                if (elapsed >= timeoutMs) {
                     currentPacket.set(null)
-                    throw EversenseWriteException("Timed out waiting for response after ${WRITE_TIMEOUT_MS}ms — packet: ${packet.getAnnotation()?.responseId}")
+                    throw EversenseWriteException("Timed out waiting for response after ${timeoutMs}ms — packet: ${packet.getAnnotation()?.responseId}")
+                } else if (packet.isErrorResponse) {
+                    currentPacket.set(null)
+                    throw EversenseWriteException("Transmitter returned error response — packet: ${packet.getAnnotation()?.responseId}")
                 }
             } catch (e: EversenseWriteException) {
                 throw e
@@ -478,6 +484,8 @@ class EversenseGattCallback(
 
         EversenseLogger.info(TAG, "E3 auth complete — ready for full sync")
         EversenseE3Communicator.fullSync(this, preferences, plugin.watchers)
+        EversenseLogger.info(TAG, "E3 transmitter ready — notifying watchers")
+        handler.post { plugin.watchers.forEach { it.onTransmitterReady() } }
     }
 
     @SuppressLint("MissingPermission")
@@ -507,6 +515,11 @@ class EversenseGattCallback(
                     return
                 }
 
+                // Cache access token so it can be used for cloud uploads without re-login
+                val expiryMs = System.currentTimeMillis() + (authSession.expires_in * 1000L)
+                preferences.edit().putString(StorageKeys.ACCESS_TOKEN, authSession.access_token)
+                    .putLong(StorageKeys.ACCESS_TOKEN_EXPIRY, expiryMs).apply()
+
                 val fleet = networkExecutor.submit<Any?> {
                     EversenseHttp365Util.getFleetSecretV2(
                         accessToken = authSession.access_token,
@@ -543,6 +556,8 @@ class EversenseGattCallback(
 
             EversenseLogger.info(TAG, "365 auth complete — ready for full sync")
             Eversense365Communicator.fullSync(this, preferences, plugin.watchers)
+            EversenseLogger.info(TAG, "365 transmitter ready — notifying watchers")
+            handler.post { plugin.watchers.forEach { it.onTransmitterReady() } }
 
         } catch (exception: Exception) {
             EversenseLogger.error(TAG, "[365] authV2 failed: $exception")

plugins/eversense/src/main/kotlin/com/nightscout/eversense/EversenseGattCallback.kt

@@ -11,4 +11,5 @@ interface EversenseWatcher {
     fun onConnectionChanged(connected: Boolean)
     fun onAlarmReceived(alarm: ActiveAlarm) {}
     fun onTransmitterNotPlaced() {}
+    fun onTransmitterReady() {}
 }

plugins/eversense/src/main/kotlin/com/nightscout/eversense/callbacks/EversenseWatcher.kt

@@ -0,0 +1,38 @@
+package com.nightscout.eversense.enums
+
+enum class BatteryLevel(val code: Int) {
+    PERCENTAGE_0(0),
+    PERCENTAGE_5(1),
+    PERCENTAGE_10(2),
+    PERCENTAGE_25(3),
+    PERCENTAGE_35(4),
+    PERCENTAGE_45(5),
+    PERCENTAGE_55(6),
+    PERCENTAGE_65(7),
+    PERCENTAGE_75(8),
+    PERCENTAGE_85(9),
+    PERCENTAGE_95(10),
+    PERCENTAGE_100(11),
+    UNKNOWN(255);
+
+    fun toPercentage(): Int = when (this) {
+        PERCENTAGE_0 -> 0
+        PERCENTAGE_5 -> 5
+        PERCENTAGE_10 -> 10
+        PERCENTAGE_25 -> 25
+        PERCENTAGE_35 -> 35
+        PERCENTAGE_45 -> 45
+        PERCENTAGE_55 -> 55
+        PERCENTAGE_65 -> 65
+        PERCENTAGE_75 -> 75
+        PERCENTAGE_85 -> 85
+        PERCENTAGE_95 -> 95
+        PERCENTAGE_100 -> 100
+        UNKNOWN -> -1
+    }
+
+    companion object {
+        fun from(code: Int): BatteryLevel =
+            values().firstOrNull { it.code == code } ?: UNKNOWN
+    }
+}

plugins/eversense/src/main/kotlin/com/nightscout/eversense/enums/BatteryLevel.kt

@@ -0,0 +1,46 @@
+package com.nightscout.eversense.enums
+
+enum class CalibrationFlag(val code: Int) {
+    NOT_ENTERED_FOR_CALIBRATION(0),
+    ACTUALLY_USED_FOR_CALIBRATION(1),
+    MARKED_SUSPICIOUS(2),
+    GLUCOSE_TOO_LOW_TO_READ(3),
+    GLUCOSE_TOO_HIGH_TO_READ(4),
+    GLUCOSE_RAPID_CHANGE(5),
+    INVALID_TIME(6),
+    INSUFFICIENT_DATA(7),
+    SENSOR_EOL(8),
+    DROPOUT_PHASE(9),
+    AUTO_LINK_MODE_ACTIVE(10),
+    SENSOR_LED_DISCONNECT(11),
+    OTHER_FAILURE(12),
+    THIS_ONE_USED_PREVIOUS_ONE_DELETED(13),
+    THIS_SUSPICIOUS_PREVIOUS_DELETED(14),
+    INSUFFICIENT_DATA_POST_FS_ENTRY(15),
+    UNKNOWN_FAILURE(255);
+
+    fun getTitle(): String = when (this) {
+        ACTUALLY_USED_FOR_CALIBRATION,
+        NOT_ENTERED_FOR_CALIBRATION -> "Calibration accepted"
+        MARKED_SUSPICIOUS -> "Suspicious"
+        GLUCOSE_TOO_LOW_TO_READ -> "Glucose too low"
+        GLUCOSE_TOO_HIGH_TO_READ -> "Glucose too high"
+        GLUCOSE_RAPID_CHANGE -> "Glucose changing too fast"
+        INVALID_TIME -> "Invalid time"
+        INSUFFICIENT_DATA,
+        INSUFFICIENT_DATA_POST_FS_ENTRY -> "Insufficient data"
+        SENSOR_EOL -> "Sensor End of Life"
+        DROPOUT_PHASE -> "Dropout phase"
+        AUTO_LINK_MODE_ACTIVE -> "Autolink"
+        SENSOR_LED_DISCONNECT -> "Sensor disconnected"
+        OTHER_FAILURE -> "Other failure"
+        THIS_ONE_USED_PREVIOUS_ONE_DELETED,
+        THIS_SUSPICIOUS_PREVIOUS_DELETED -> "Previous calibration deleted"
+        UNKNOWN_FAILURE -> "Unknown failure"
+    }
+
+    companion object {
+        fun from(code: Int): CalibrationFlag =
+            values().firstOrNull { it.code == code } ?: UNKNOWN_FAILURE
+    }
+}