@glassly/bluetooth-sdk 0.1.0-dev.26

package/android/src/test/java/com/glassly/bluetoothsdk/otaserver/LocalOtaServerTest.kt

@@ -0,0 +1,82 @@
+package com.glassly.bluetoothsdk.otaserver
+
+import java.io.File
+import java.net.HttpURLConnection
+import java.net.URL
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+
+class LocalOtaServerTest {
+    private lateinit var server: LocalOtaServer
+    private lateinit var artifactFile: File
+    private var port = 0
+
+    private val manifest = """{"apps":{"com.mentra.asg_client":{"versionCode":1}}}"""
+    private val artifactBytes = ByteArray(1024) { (it % 251).toByte() }
+    private val sha = "a".repeat(64)
+
+    @Before
+    fun startServer() {
+        artifactFile = File.createTempFile("ota-artifact", ".bin").apply {
+            writeBytes(artifactBytes)
+        }
+        server = LocalOtaServer(onLog = {})
+        server.configure(manifest, mapOf(sha to artifactFile))
+        port = server.start("127.0.0.1", 0)
+    }
+
+    @After
+    fun stopServer() {
+        server.close()
+        artifactFile.delete()
+    }
+
+    @Test
+    fun `serves the configured manifest`() {
+        val connection = open("/version.json")
+        assertThat(connection.responseCode).isEqualTo(200)
+        assertThat(connection.contentType).isEqualTo("application/json")
+        assertThat(connection.inputStream.readBytes().decodeToString()).isEqualTo(manifest)
+    }
+
+    @Test
+    fun `streams a full artifact`() {
+        val connection = open("/artifacts/$sha")
+        assertThat(connection.responseCode).isEqualTo(200)
+        assertThat(connection.inputStream.readBytes()).isEqualTo(artifactBytes)
+    }
+
+    @Test
+    fun `returns 404 for unknown artifacts`() {
+        val connection = open("/artifacts/${"b".repeat(64)}")
+        assertThat(connection.responseCode).isEqualTo(404)
+    }
+
+    @Test
+    fun `rejects non-GET methods`() {
+        val connection = open("/version.json")
+        connection.requestMethod = "POST"
+        connection.doOutput = true
+        connection.outputStream.use { it.write("{}".toByteArray()) }
+        assertThat(connection.responseCode).isEqualTo(405)
+    }
+
+    @Test
+    fun `reconfigures while running`() {
+        server.configure("""{"updated":true}""", emptyMap())
+        val manifestConnection = open("/version.json")
+        assertThat(manifestConnection.inputStream.readBytes().decodeToString())
+            .isEqualTo("""{"updated":true}""")
+        val artifactConnection = open("/artifacts/$sha")
+        assertThat(artifactConnection.responseCode).isEqualTo(404)
+    }
+
+    private fun open(path: String): HttpURLConnection {
+        val connection = URL("http://127.0.0.1:$port$path").openConnection() as HttpURLConnection
+        connection.connectTimeout = 5_000
+        connection.readTimeout = 5_000
+        return connection
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/photoreceiver/LocalPhotoReceiverRegistryTest.java

@@ -0,0 +1,75 @@
+package com.glassly.bluetoothsdk.photoreceiver;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.After;
+import org.junit.Test;
+
+public class LocalPhotoReceiverRegistryTest {
+
+    @After
+    public void tearDown() {
+        LocalPhotoReceiverRegistry.unregister();
+    }
+
+    @Test
+    public void loopbackUploadUrlFor_rewritesRegisteredReceiverUrl() {
+        LocalPhotoReceiverRegistry.register("http://192.168.1.20:8787/upload");
+
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://192.168.1.20:8787/upload"))
+                .isEqualTo("http://127.0.0.1:8787/upload");
+    }
+
+    @Test
+    public void loopbackUploadUrlFor_doesNotRewriteDifferentHostOnSamePort() {
+        LocalPhotoReceiverRegistry.register("http://192.168.1.20:8787/upload");
+
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("https://api.example.com:8787/upload"))
+                .isNull();
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://devbox:8787/upload"))
+                .isNull();
+    }
+
+    @Test
+    public void loopbackUploadUrlFor_doesNotRewriteDifferentPath() {
+        LocalPhotoReceiverRegistry.register("http://192.168.1.20:8787/upload");
+
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://192.168.1.20:8787/other"))
+                .isNull();
+    }
+
+    @Test
+    public void loopbackUploadUrlFor_keepsEarlierReceiverUrlsUntilUnregister() {
+        LocalPhotoReceiverRegistry.register("http://192.168.1.20:8787/upload");
+        LocalPhotoReceiverRegistry.register("http://10.0.0.12:8787/upload");
+
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://192.168.1.20:8787/upload"))
+                .isEqualTo("http://127.0.0.1:8787/upload");
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://10.0.0.12:8787/upload"))
+                .isEqualTo("http://127.0.0.1:8787/upload");
+
+        LocalPhotoReceiverRegistry.unregister();
+
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://192.168.1.20:8787/upload"))
+                .isNull();
+    }
+
+    @Test
+    public void register_keepsExistingReceiverUrlsWhenInvalidUrlArrives() {
+        LocalPhotoReceiverRegistry.register("http://192.168.1.20:8787/upload");
+        LocalPhotoReceiverRegistry.register("not a url");
+
+        assertThat(LocalPhotoReceiverRegistry.isActive()).isTrue();
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("http://192.168.1.20:8787/upload"))
+                .isEqualTo("http://127.0.0.1:8787/upload");
+    }
+
+    @Test
+    public void register_rejectsInvalidReceiverUrl() {
+        LocalPhotoReceiverRegistry.register("https://api.example.com/photo");
+
+        assertThat(LocalPhotoReceiverRegistry.isActive()).isFalse();
+        assertThat(LocalPhotoReceiverRegistry.loopbackUploadUrlFor("https://api.example.com/photo"))
+                .isNull();
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/services/ForegroundServiceTypeTest.kt

@@ -0,0 +1,69 @@
+package com.glassly.bluetoothsdk.services
+
+import android.content.pm.ServiceInfo
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ForegroundServiceTypeTest {
+    @Test
+    fun `bootstrap starts as dataSync`() {
+        assertEquals(
+            ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+            ForegroundService.bootstrapServiceType(),
+        )
+    }
+
+    @Test
+    fun `preferred types remove dataSync once connectedDevice is available`() {
+        val serviceType =
+            ForegroundService.preferredServiceType(
+                hasConnectedDeviceAccess = true,
+                hasMicrophoneAccess = false,
+                hasLocationAccess = false,
+                includeMediaPlayback = false,
+            )
+
+        assertTrue(
+            serviceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE != 0,
+        )
+        assertEquals(
+            0,
+            serviceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+        )
+    }
+
+    @Test
+    fun `preferred types retain dataSync only when no better type is available`() {
+        val serviceType =
+            ForegroundService.preferredServiceType(
+                hasConnectedDeviceAccess = false,
+                hasMicrophoneAccess = false,
+                hasLocationAccess = false,
+                includeMediaPlayback = false,
+            )
+
+        assertEquals(
+            ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+            serviceType,
+        )
+    }
+
+    @Test
+    fun `production mask never carries dataSync with media playback`() {
+        val serviceType =
+            ForegroundService.preferredServiceType(
+                hasConnectedDeviceAccess = true,
+                hasMicrophoneAccess = true,
+                hasLocationAccess = true,
+            )
+
+        assertEquals(
+            0,
+            serviceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+        )
+        assertTrue(
+            serviceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK != 0,
+        )
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/sgcs/Ar99AdvertisementMatcherTest.java

@@ -0,0 +1,22 @@
+package com.glassly.bluetoothsdk.sgcs;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class Ar99AdvertisementMatcherTest {
+
+  @Test
+  public void supportsOnlyDocumentedProjectIdentifiers() {
+    assertThat(Ar99.isSupportedProjectName("AR99")).isTrue();
+    assertThat(Ar99.isSupportedProjectName("ar99")).isTrue();
+
+    assertThat(Ar99.isSupportedProjectName("AF98")).isFalse();
+    assertThat(Ar99.isSupportedProjectName("AF99")).isFalse();
+    assertThat(Ar99.isSupportedProjectName("HVXM")).isFalse();
+    assertThat(Ar99.isSupportedProjectName("HVXF")).isFalse();
+    assertThat(Ar99.isSupportedProjectName("AR99X")).isFalse();
+    assertThat(Ar99.isSupportedProjectName("")).isFalse();
+    assertThat(Ar99.isSupportedProjectName(null)).isFalse();
+  }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/sgcs/BesOtaHeartbeatGuardTest.kt

@@ -0,0 +1,73 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class BesOtaHeartbeatGuardTest {
+    @Test
+    fun leaseSuppressesUntilDeadlineAndThenExpires() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+        guard.refresh(1_000)
+
+        assertTrue(guard.shouldSuppress(120_999))
+        assertFalse(guard.shouldSuppress(121_000))
+    }
+
+    @Test
+    fun progressRenewsLease() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+        guard.refresh(1_000)
+        guard.refresh(60_000)
+
+        assertTrue(guard.shouldSuppress(121_000))
+        assertFalse(guard.shouldSuppress(180_000))
+    }
+
+    @Test
+    fun terminalStatusClearsLeaseImmediately() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+        guard.refresh(1_000)
+        guard.clear()
+
+        assertFalse(guard.shouldSuppress(1_001))
+    }
+
+    @Test
+    fun besInstallStatusArmsLease() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+
+        guard.observeOtaStatus("BES", "INSTALL", "in_progress", 1_000)
+
+        assertTrue(guard.shouldSuppress(120_999))
+    }
+
+    @Test
+    fun legacyBesInstallStatusUsesSameLease() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+
+        guard.observeOtaStatus("bes", "install", "in_progress", 5_000)
+
+        assertTrue(guard.shouldSuppress(124_999))
+    }
+
+    @Test
+    fun unrelatedStatusDoesNotClearActiveLease() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+        guard.observeOtaStatus("bes", "install", "in_progress", 1_000)
+
+        guard.observeOtaStatus("apk", "install", "complete", 2_000)
+
+        assertTrue(guard.shouldSuppress(120_999))
+    }
+
+    @Test
+    fun besStepCompleteClearsLease() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+        guard.observeOtaStatus("bes", "install", "in_progress", 1_000)
+
+        guard.observeOtaStatus("bes", "install", "step_complete", 2_000)
+
+        assertFalse(guard.shouldSuppress(2_001))
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/sgcs/BesOtaProgressMapperTest.kt

@@ -0,0 +1,67 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class BesOtaProgressMapperTest {
+    @Test
+    fun explicitSuccessIsTerminal() {
+        val mapping = mapBesOtaProgress("success", 0, null)
+
+        assertEquals("FINISHED", mapping.status)
+        assertEquals(100, mapping.progress)
+        assertNull(mapping.errorMessage)
+    }
+
+    @Test
+    fun hundredPercentUpdateIsAlsoNonterminal() {
+        val mapping = mapBesOtaProgress("update", 100, null)
+
+        assertEquals("PROGRESS", mapping.status)
+        assertEquals(95, mapping.progress)
+    }
+
+    @Test
+    fun roundedHundredPercentUpdateIsCappedBelowTerminal() {
+        val mapping = mapBesOtaProgress("update", 98, null)
+
+        assertEquals("PROGRESS", mapping.status)
+        assertEquals(95, mapping.progress)
+    }
+
+    @Test
+    fun explicitBesErrorRemainsTerminalFailure() {
+        val mapping = mapBesOtaProgress("error", 65, "CRC failed")
+
+        assertEquals("FAILED", mapping.status)
+        assertEquals(65, mapping.progress)
+        assertEquals("CRC failed", mapping.errorMessage)
+    }
+
+    @Test
+    fun blankBesErrorUsesStableFallback() {
+        val mapping = mapBesOtaProgress("error", 65, "   ")
+
+        assertEquals("FAILED", mapping.status)
+        assertEquals("BES update failed", mapping.errorMessage)
+    }
+
+    @Test
+    fun ordinaryUpdateProgressRemainsNonterminal() {
+        val mapping = mapBesOtaProgress("update", 40, null)
+
+        assertEquals("PROGRESS", mapping.status)
+        assertEquals(40, mapping.progress)
+        assertNull(mapping.errorMessage)
+    }
+
+    @Test
+    fun failAliasRemainsTerminalFailure() {
+        val mapping = mapBesOtaProgress("fail", 25, "apply failed")
+
+        assertEquals("FAILED", mapping.status)
+        assertEquals(25, mapping.progress)
+        assertEquals("apply failed", mapping.errorMessage)
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/sgcs/EvenRleTest.kt

@@ -0,0 +1,63 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * Byte-exactness tests for the Even RLE nav-map codec. The compressMode flag and payload
+ * must match iOS G2.swift's EvenRle exactly — the firmware ACKs a mismatched compressMode
+ * without error and silently never paints the bitmap, so codec drift is invisible on-device.
+ */
+class EvenRleTest {
+    @Test
+    fun emptyInputCompressesToEmpty() {
+        assertArrayEquals(ByteArray(0), EvenRle.compress(ByteArray(0)))
+    }
+
+    @Test
+    fun singleByteRun() {
+        assertArrayEquals(byteArrayOf(0x01, 0x42), EvenRle.compress(byteArrayOf(0x42)))
+    }
+
+    @Test
+    fun shortRunsEncodeAsLengthValuePairs() {
+        val input = byteArrayOf(0xAA.toByte(), 0xAA.toByte(), 0xAA.toByte(), 0xBB.toByte())
+        assertArrayEquals(
+            byteArrayOf(0x03, 0xAA.toByte(), 0x01, 0xBB.toByte()),
+            EvenRle.compress(input)
+        )
+    }
+
+    @Test
+    fun runsAreCappedAt255() {
+        val input = ByteArray(300) { 0x11 }
+        assertArrayEquals(
+            byteArrayOf(0xFF.toByte(), 0x11, 0x2D, 0x11),
+            EvenRle.compress(input)
+        )
+    }
+
+    @Test
+    fun smartCompressUsesRleForRepetitiveInput() {
+        val input = ByteArray(1000) { 0x00 }
+        val (payload, mode) = EvenRle.smartCompress(input)
+        assertEquals(1, mode)
+        // 1000 = 3×255 + 235 → four [len][value] pairs.
+        assertArrayEquals(
+            byteArrayOf(
+                0xFF.toByte(), 0x00, 0xFF.toByte(), 0x00, 0xFF.toByte(), 0x00, 0xEB.toByte(), 0x00
+            ),
+            payload
+        )
+    }
+
+    @Test
+    fun smartCompressFallsBackToRawWhenSavingsUnderFivePercent() {
+        // Alternating bytes double under RLE — must ship raw with compressMode 0.
+        val input = ByteArray(64) { (it % 2).toByte() }
+        val (payload, mode) = EvenRle.smartCompress(input)
+        assertEquals(0, mode)
+        assertArrayEquals(input, payload)
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/sgcs/G1TextSanitizerTest.kt

@@ -0,0 +1,31 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class G1TextSanitizerTest {
+
+    @Test
+    fun `strips Vietnamese diacritics unsupported by G1`() {
+        assertThat(sanitizeG1DisplayText("Tiếng Việt: Đặng, Nguyễn, phở bò"))
+            .isEqualTo("Tieng Viet: Dang, Nguyen, pho bo")
+    }
+
+    @Test
+    fun `handles decomposed marks and preserves layout`() {
+        assertThat(sanitizeG1DisplayText("Cafe\u0301\nĐa Nang"))
+            .isEqualTo("Cafe\nDa Nang")
+    }
+
+    @Test
+    fun `expands Latin letters that do not decompose into combining marks`() {
+        assertThat(sanitizeG1DisplayText("Øresund Łódź Æsir Œuvre Straße Ðingvellir Þingvellir"))
+            .isEqualTo("Oresund Lodz AEsir OEuvre Strasse Dingvellir THingvellir")
+    }
+
+    @Test
+    fun `leaves text without diacritics unchanged`() {
+        assertThat(sanitizeG1DisplayText("Hello, world! 123"))
+            .isEqualTo("Hello, world! 123")
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/sgcs/G2CfwClassificationTest.kt

@@ -0,0 +1,89 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Pins the stock-vs-CFW identity rules that gate the connect banner. A
+ * regression here re-opens the stuck "// Glassly connected" bug: text drawn
+ * down the stock path before classification, cleared down the CFW path after
+ * it, never leaves the glass.
+ */
+class G2CfwClassificationTest {
+    private fun classify(
+        capability: String?,
+        definitive: Boolean = false,
+        current: String? = null,
+    ) = G2CfwClassification.classify(capability?.toByteArray(Charsets.UTF_8), definitive, current)
+
+    // ── CFW detection ───────────────────────────────────────────────────────
+
+    @Test
+    fun cfwBannerClassifiesWithFeaturesAndRevision() {
+        val result = classify("EVENCFW/15 img640 imgz rle directfb font15")
+        assertNotNull(result)
+        assertTrue(result!!.isCfw)
+        assertEquals("EVENCFW/15 img640 imgz rle directfb font15", result.capabilityString)
+        assertEquals(listOf("img640", "imgz", "rle", "directfb", "font15"), result.features)
+        assertEquals(15, result.protocolVersion)
+    }
+
+    @Test
+    fun cfwDetectionDoesNotWaitForADefinitiveResponse() {
+        // The banner may ride any settings packet; requiring `definitive` would
+        // delay classification past the connect banner and re-split the paths.
+        assertTrue(classify("EVENCFW/12 img640", definitive = false)!!.isCfw)
+    }
+
+    @Test
+    fun cfwBannerTrimsNulTermination() {
+        val bytes = "EVENCFW/12 img640".toByteArray(Charsets.UTF_8) + byteArrayOf(0, 0)
+        val result = G2CfwClassification.classify(bytes, definitive = false, currentCapability = null)
+        assertEquals("EVENCFW/12 img640", result!!.capabilityString)
+        assertEquals(listOf("img640"), result.features)
+    }
+
+    @Test
+    fun malformedRevisionFallsBackToZero() {
+        val result = classify("EVENCFW/beta img640")
+        assertTrue(result!!.isCfw)
+        assertEquals(0, result.protocolVersion)
+    }
+
+    // ── Stock classification ────────────────────────────────────────────────
+
+    @Test
+    fun definitiveAbsenceClassifiesStock() {
+        val result = classify(null, definitive = true)
+        assertNotNull(result)
+        assertFalse(result!!.isCfw)
+        assertEquals(G2CfwClassification.STOCK, result)
+    }
+
+    @Test
+    fun definitiveNonCfwPayloadClassifiesStock() {
+        assertEquals(G2CfwClassification.STOCK, classify("something-else", definitive = true))
+    }
+
+    // ── Packets that prove nothing ──────────────────────────────────────────
+
+    @Test
+    fun nonDefinitiveAbsenceLeavesConnectionUnclassified() {
+        // Individual settings packets can legitimately omit field 100 or
+        // arrive truncated — only a deviceReceiveRequest response is proof.
+        assertNull(classify(null, definitive = false))
+        assertNull(classify("garbage", definitive = false))
+    }
+
+    @Test
+    fun definitiveAbsenceNeverDowngradesDetectedCfw() {
+        // Firmware identity is connection-sticky: downgrading would
+        // reinterpret an installed mode-6 carrier as a stock BMP.
+        assertNull(classify(null, definitive = true, current = "EVENCFW/15 img640"))
+        assertNull(classify("garbage", definitive = true, current = "EVENCFW/15 img640"))
+    }
+}