fix: avoid fast pair samsung misclassification

MichalMatu · MichalMatu · commit aa1e45e71723 · 2026-06-29T06:30:38.000+02:00
diff --git a/core/data/src/main/java/io/blueeye/core/data/classifier/pipeline/NameClassifier.kt b/core/data/src/main/java/io/blueeye/core/data/classifier/pipeline/NameClassifier.kt
@@ -16,10 +16,10 @@ object NameClassifier {
 
         return checkHeadphones(lowerName)
             ?: checkWearables(lowerName)
+            ?: checkTrackers(lowerName)
             ?: checkPhones(lowerName)
             ?: checkComputers(lowerName)
             ?: checkTv(lowerName)
-            ?: checkTrackers(lowerName)
             ?: DeviceType.UNKNOWN
     }
 
diff --git a/core/data/src/main/java/io/blueeye/core/data/classifier/vendor/strategy/SamsungStrategy.kt b/core/data/src/main/java/io/blueeye/core/data/classifier/vendor/strategy/SamsungStrategy.kt
@@ -14,8 +14,7 @@ constructor(
 ) : VendorStrategy {
     override fun canHandle(input: VendorScanInput): Boolean {
         return input.hasManufacturer(ManufacturerIds.SAMSUNG) ||
-            input.hasServiceUuid(SMARTTHINGS_FIND_UUID) ||
-            input.hasServiceUuid(QUICK_SHARE_UUID)
+            input.hasServiceUuid(SMARTTHINGS_FIND_UUID)
     }
 
     override fun decode(input: VendorScanInput): VendorScanResult {
@@ -30,7 +29,7 @@ constructor(
             if (deviceType == DeviceType.UNKNOWN) deviceType = DeviceType.SAMSUNG_TAG
         }
 
-        if (input.hasServiceUuid(QUICK_SHARE_UUID)) {
+        if (input.hasManufacturer(ManufacturerIds.SAMSUNG) && input.hasServiceUuid(QUICK_SHARE_UUID)) {
             extraInfo += "Quick Share / Ecosystem. "
             if (deviceType == DeviceType.UNKNOWN) deviceType = DeviceType.PHONE
         }
diff --git a/core/data/src/main/java/io/blueeye/core/data/repository/handler/ble/DeviceTypeResolver.kt b/core/data/src/main/java/io/blueeye/core/data/repository/handler/ble/DeviceTypeResolver.kt
@@ -25,6 +25,7 @@ object DeviceTypeResolver {
         modelNumber: String?,
         vendorType: DeviceType,
         scanType: DeviceType,
+        nameType: DeviceType,
     ): DeviceType {
         // 1. Model-based classification is the strongest identity signal.
         if (modelNumber != null) {
@@ -40,7 +41,8 @@ object DeviceTypeResolver {
         // - Specific > Generic
 
         val candidates = listOf(existingType, vendorType, scanType)
-        return candidates.maxByOrNull { getPriority(it) } ?: DeviceType.UNKNOWN
+        val resolved = candidates.maxByOrNull { getPriority(it) } ?: DeviceType.UNKNOWN
+        return resolveExplicitNameConflict(nameType, resolved)
     }
 
     private fun getPriority(type: DeviceType): Int {
@@ -58,7 +60,44 @@ object DeviceTypeResolver {
     fun resolveForNew(
         vendorType: DeviceType,
         scanType: DeviceType,
+        nameType: DeviceType,
     ): DeviceType {
-        return listOf(vendorType, scanType).maxByOrNull { getPriority(it) } ?: DeviceType.UNKNOWN
+        val resolved = listOf(vendorType, scanType).maxByOrNull { getPriority(it) } ?: DeviceType.UNKNOWN
+        return resolveExplicitNameConflict(nameType, resolved)
     }
+
+    private fun resolveExplicitNameConflict(
+        nameType: DeviceType,
+        resolvedType: DeviceType,
+    ): DeviceType {
+        if (nameType == DeviceType.UNKNOWN) return resolvedType
+        if (resolvedType == DeviceType.UNKNOWN || resolvedType == nameType) return nameType
+
+        return if (nameType in EXPLICIT_NAME_TYPES && resolvedType in CONSUMER_IDENTITY_TYPES) {
+            nameType
+        } else {
+            resolvedType
+        }
+    }
+
+    private val EXPLICIT_NAME_TYPES =
+        setOf(
+            DeviceType.HEADPHONES,
+            DeviceType.SPEAKER,
+            DeviceType.TV,
+            DeviceType.PHONE,
+            DeviceType.TABLET,
+            DeviceType.LAPTOP,
+            DeviceType.PC,
+            DeviceType.CONSOLE,
+            DeviceType.WEARABLE,
+            DeviceType.WATCH,
+            DeviceType.AIRTAG,
+            DeviceType.TILE,
+            DeviceType.SAMSUNG_TAG,
+            DeviceType.TRACKER,
+            DeviceType.TAG,
+        )
+
+    private val CONSUMER_IDENTITY_TYPES = EXPLICIT_NAME_TYPES + DeviceType.AUDIO_VIDEO
 }
diff --git a/core/data/src/main/java/io/blueeye/core/data/repository/handler/ble/ScanResultClassifier.kt b/core/data/src/main/java/io/blueeye/core/data/repository/handler/ble/ScanResultClassifier.kt
@@ -60,11 +60,13 @@ class ScanResultClassifier @Inject constructor(
                 modelNumber = existing.modelNumber,
                 vendorType = ctx.vendorDeviceType,
                 scanType = ctx.deviceType,
+                nameType = deviceClassifier.classifyByName(ctx.sanitizedName ?: ctx.name),
             )
         } else {
             DeviceTypeResolver.resolveForNew(
                 vendorType = ctx.vendorDeviceType,
                 scanType = ctx.deviceType,
+                nameType = deviceClassifier.classifyByName(ctx.sanitizedName ?: ctx.name),
             )
         }
     }
diff --git a/core/data/src/test/kotlin/io/blueeye/core/data/classifier/vendor/strategy/SamsungStrategyTest.kt b/core/data/src/test/kotlin/io/blueeye/core/data/classifier/vendor/strategy/SamsungStrategyTest.kt
@@ -4,6 +4,7 @@ import io.blueeye.core.data.classifier.vendor.VendorScanInput
 import io.blueeye.core.decoders.parser.samsung.SamsungManufacturerParser
 import io.blueeye.core.model.DeviceType
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Test
 import org.mockito.kotlin.mock
@@ -31,7 +32,20 @@ class SamsungStrategyTest {
         verifyNoInteractions(manufacturerParser)
     }
 
+    @Test
+    fun `Fast Pair service uuid alone is not treated as Samsung Quick Share`() {
+        val input =
+            VendorScanInput(
+                manufacturerRecords = emptyMap(),
+                serviceUuids = listOf(FAST_PAIR_UUID),
+            )
+
+        assertFalse(strategy.canHandle(input))
+        verifyNoInteractions(manufacturerParser)
+    }
+
     private companion object {
+        private const val FAST_PAIR_UUID = "0000fe2c-0000-1000-8000-00805f9b34fb"
         private const val SMARTTHINGS_FIND_UUID = "0000fd5a-0000-1000-8000-00805f9b34fb"
     }
 }
diff --git a/core/data/src/test/kotlin/io/blueeye/core/data/repository/handler/ble/DeviceTypeResolverTest.kt b/core/data/src/test/kotlin/io/blueeye/core/data/repository/handler/ble/DeviceTypeResolverTest.kt
@@ -11,6 +11,7 @@ class DeviceTypeResolverTest {
             DeviceTypeResolver.resolveForNew(
                 vendorType = DeviceType.TAG,
                 scanType = DeviceType.TV,
+                nameType = DeviceType.TV,
             )
 
         assertEquals(DeviceType.TV, resolved)
@@ -22,8 +23,21 @@ class DeviceTypeResolverTest {
             DeviceTypeResolver.resolveForNew(
                 vendorType = DeviceType.SAMSUNG_TAG,
                 scanType = DeviceType.UNKNOWN,
+                nameType = DeviceType.UNKNOWN,
             )
 
         assertEquals(DeviceType.SAMSUNG_TAG, resolved)
     }
+
+    @Test
+    fun `explicit audio name wins over generic phone vendor signal`() {
+        val resolved =
+            DeviceTypeResolver.resolveForNew(
+                vendorType = DeviceType.PHONE,
+                scanType = DeviceType.HEADPHONES,
+                nameType = DeviceType.HEADPHONES,
+            )
+
+        assertEquals(DeviceType.HEADPHONES, resolved)
+    }
 }
diff --git a/feature/radar/src/main/java/io/blueeye/feature/radar/presentation/RadarUiCardOrder.kt b/feature/radar/src/main/java/io/blueeye/feature/radar/presentation/RadarUiCardOrder.kt
@@ -4,7 +4,27 @@ internal object RadarUiCardOrder {
     val comparator: Comparator<RadarUiItem> =
         compareByDescending<RadarUiItem> { it.isInWatchlist }
             .thenByDescending { it.isNew }
+            .thenByDescending { signalBucket(it.signalInfo.rssi) }
+            .thenByDescending { normalizedRssi(it.signalInfo.rssi) }
+            .thenByDescending { it.device.lastSeenAt }
             .thenByDescending { it.device.firstSeenAt }
             .thenBy { it.displayName.lowercase() }
             .thenBy { it.fingerprint }
+
+    private fun signalBucket(rssi: Int): Int =
+        when {
+            rssi == UNKNOWN_RSSI -> 0
+            rssi >= STRONG_RSSI -> 3
+            rssi >= MEDIUM_RSSI -> 2
+            rssi >= WEAK_RSSI -> 1
+            else -> 0
+        }
+
+    private fun normalizedRssi(rssi: Int): Int =
+        if (rssi == UNKNOWN_RSSI) Int.MIN_VALUE else rssi
+
+    private const val STRONG_RSSI = -60
+    private const val MEDIUM_RSSI = -80
+    private const val WEAK_RSSI = -90
+    private const val UNKNOWN_RSSI = 0
 }
diff --git a/feature/radar/src/test/java/io/blueeye/feature/radar/presentation/RadarUiCardOrderTest.kt b/feature/radar/src/test/java/io/blueeye/feature/radar/presentation/RadarUiCardOrderTest.kt
@@ -9,21 +9,25 @@ import org.junit.Test
 
 class RadarUiCardOrderTest {
     @Test
-    fun `card order stays stable when rssi changes`() {
-        val firstScan =
+    fun `strong nearby devices sort before newer weak devices`() {
+        val sorted =
             listOf(
-                item(fingerprint = "bravo", displayName = "Bravo", rssi = -42),
-                item(fingerprint = "alpha", displayName = "Alpha", rssi = -88),
+                item(fingerprint = "weak-new", displayName = "A weak", rssi = -93, firstSeenAt = NOW + 2_000),
+                item(fingerprint = "strong-old", displayName = "B strong", rssi = -52, firstSeenAt = NOW),
             ).sortedWith(RadarUiCardOrder.comparator)
 
-        val nextScan =
+        assertEquals(listOf("strong-old", "weak-new"), sorted.map { it.fingerprint })
+    }
+
+    @Test
+    fun `same signal bucket uses rssi before recency`() {
+        val sorted =
             listOf(
-                item(fingerprint = "bravo", displayName = "Bravo", rssi = -88),
-                item(fingerprint = "alpha", displayName = "Alpha", rssi = -42),
+                item(fingerprint = "medium-weaker-new", displayName = "A medium", rssi = -78, firstSeenAt = NOW + 2_000),
+                item(fingerprint = "medium-stronger-old", displayName = "B medium", rssi = -65, firstSeenAt = NOW),
             ).sortedWith(RadarUiCardOrder.comparator)
 
-        assertEquals(listOf("alpha", "bravo"), firstScan.map { it.fingerprint })
-        assertEquals(firstScan.map { it.fingerprint }, nextScan.map { it.fingerprint })
+        assertEquals(listOf("medium-stronger-old", "medium-weaker-new"), sorted.map { it.fingerprint })
     }
 
     @Test
@@ -44,6 +48,7 @@ class RadarUiCardOrderTest {
         rssi: Int = -60,
         isInWatchlist: Boolean = false,
         isNew: Boolean = false,
+        firstSeenAt: Long = NOW,
     ): RadarUiItem =
         RadarUiMapper.mapToUi(
             device =
@@ -64,7 +69,7 @@ class RadarUiCardOrderTest {
                     userNotes = null,
                     alertSound = false,
                     alertVibration = false,
-                    firstSeenAt = NOW,
+                    firstSeenAt = firstSeenAt,
                     lastSeenAt = NOW,
                     rssi = rssi,
                     encounterCount = 1,

Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,7 @@ constructor(`
`14`	`14`	`) : VendorStrategy {`
`15`	`15`	`override fun canHandle(input: VendorScanInput): Boolean {`
`16`	`16`	`return input.hasManufacturer(ManufacturerIds.SAMSUNG) \|\|`
`17`		`- input.hasServiceUuid(SMARTTHINGS_FIND_UUID) \|\|`
`18`		`- input.hasServiceUuid(QUICK_SHARE_UUID)`
	`17`	`+ input.hasServiceUuid(SMARTTHINGS_FIND_UUID)`
`19`	`18`	`}`
`20`	`19`
`21`	`20`	`override fun decode(input: VendorScanInput): VendorScanResult {`
`@@ -30,7 +29,7 @@ constructor(`
`30`	`29`	`if (deviceType == DeviceType.UNKNOWN) deviceType = DeviceType.SAMSUNG_TAG`
`31`	`30`	`}`
`32`	`31`
`33`		`- if (input.hasServiceUuid(QUICK_SHARE_UUID)) {`
	`32`	`+ if (input.hasManufacturer(ManufacturerIds.SAMSUNG) && input.hasServiceUuid(QUICK_SHARE_UUID)) {`
`34`	`33`	`extraInfo += "Quick Share / Ecosystem. "`
`35`	`34`	`if (deviceType == DeviceType.UNKNOWN) deviceType = DeviceType.PHONE`
`36`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,11 +60,13 @@ class ScanResultClassifier @Inject constructor(`
`60`	`60`	`modelNumber = existing.modelNumber,`
`61`	`61`	`vendorType = ctx.vendorDeviceType,`
`62`	`62`	`scanType = ctx.deviceType,`
	`63`	`+ nameType = deviceClassifier.classifyByName(ctx.sanitizedName ?: ctx.name),`
`63`	`64`	`)`
`64`	`65`	`} else {`
`65`	`66`	`DeviceTypeResolver.resolveForNew(`
`66`	`67`	`vendorType = ctx.vendorDeviceType,`
`67`	`68`	`scanType = ctx.deviceType,`
	`69`	`+ nameType = deviceClassifier.classifyByName(ctx.sanitizedName ?: ctx.name),`
`68`	`70`	`)`
`69`	`71`	`}`
`70`	`72`	`}`