Use API data to calculate Wi-Fi width center frequency

Author: VREMSoftwareDevelopment

app/build.properties

@@ -1,6 +1,6 @@
 #Build Properties
-#Fri Mar 28 18:21:30 EDT 2025
-version_build=14
+#Sat Mar 29 12:14:52 EDT 2025
+version_build=15
 version_major=3
 version_minor=1
 version_patch=4

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/model/WiFiWidth.kt

@@ -23,33 +23,6 @@ import kotlin.math.abs
 
 private val CHANNEL_WIDTH_320MHZ = if (buildMinVersionT()) ScanResult.CHANNEL_WIDTH_320MHZ else 5
 
-// 5GHz: 50, 82, 114, 163 | 6GHz: 15, 47, 79, 111, 143, 175, 207
-private val frequency160Range = listOf(
-    5250 to (5170 to 5329),
-    5410 to (5330 to 5489),
-    5650 to (5490 to 5730),
-    5815 to (5735 to 5895),
-    6025 to (5945 to 6104),
-    6185 to (6105 to 6264),
-    6345 to (6265 to 6424),
-    6505 to (6425 to 6584),
-    6665 to (6585 to 6744),
-    6825 to (6745 to 6904),
-    6985 to (6905 to 7065)
-)
-private val frequency160center = frequency160Range.map { it.first }
-
-// 6GHz: 31, 95, 159, 191
-private val frequency320Range = listOf(
-    6100 to (5945 to 6264),
-    6430 to (6265 to 6584),
-    6750 to (6585 to 6904),
-    6910 to (6905 to 7065)
-)
-
-// 6GHz: 31, 63, 95, 127, 159, 191
-private val frequency320Center = listOf(6100, 6270, 6430, 6590, 6750, 6910)
-
 typealias ChannelWidth = Int
 typealias CalculateCenter = (primary: Int, center0: Int, center1: Int) -> Int
 
@@ -58,22 +31,8 @@ internal val calculateCenter40: CalculateCenter = { primary, center0, _ ->
     if (abs(primary - center0) >= WiFiWidth.MHZ_40.frequencyWidthHalf) (primary + center0) / 2 else center0
 }
 internal val calculateCenter80: CalculateCenter = { _, center0, _ -> center0 }
-internal val calculateCenter160: CalculateCenter = { primary, center0, center1 ->
-    when {
-        center1 in frequency160center -> center1
-        center0 in frequency160center -> center0
-        primary in frequency160center -> primary
-        else -> frequency160Range.firstOrNull { primary in it.second.first..it.second.second }?.first ?: center1
-    }
-}
-internal val calculateCenter320: CalculateCenter = { primary, center0, center1 ->
-    when {
-        center1 in frequency320Center -> center1
-        center0 in frequency320Center -> center0
-        primary in frequency320Center -> primary
-        else -> frequency320Range.firstOrNull { primary in it.second.first..it.second.second }?.first ?: center1
-    }
-}
+internal val calculateCenter160: CalculateCenter = { _, _, center1 -> center1 }
+internal val calculateCenter320: CalculateCenter = { _, _, center1 -> center1 }
 
 enum class WiFiWidth(val channelWidth: ChannelWidth, val frequencyWidth: Int, val guardBand: Int, val calculateCenter: CalculateCenter) {
     MHZ_20(ScanResult.CHANNEL_WIDTH_20MHZ, 20, 2, calculateCenter20),

app/src/test/kotlin/com/vrem/wifianalyzer/wifi/model/WiFiWidthTest.kt

@@ -117,135 +117,41 @@ class WiFiWidthTest {
         // setup
         val expected = 35
         // execute & validate
-        assertThat(calculateCenter80(Int.MIN_VALUE, expected, Int.MIN_VALUE)).isEqualTo(expected)
+        assertThat(calculateCenter80(0, expected, 0)).isEqualTo(expected)
         assertThat(calculateCenter80(0, expected, Int.MIN_VALUE)).isEqualTo(expected)
-        assertThat(calculateCenter80(Int.MAX_VALUE, expected, Int.MIN_VALUE)).isEqualTo(expected)
+        assertThat(calculateCenter80(0, expected, Int.MAX_VALUE)).isEqualTo(expected)
+        assertThat(calculateCenter80(Int.MIN_VALUE, expected, 0)).isEqualTo(expected)
+        assertThat(calculateCenter80(Int.MAX_VALUE, expected, 0)).isEqualTo(expected)
+        assertThat(calculateCenter80(Int.MIN_VALUE, expected, Int.MIN_VALUE)).isEqualTo(expected)
+        assertThat(calculateCenter80(Int.MAX_VALUE, expected, Int.MAX_VALUE)).isEqualTo(expected)
     }
 
     @Test
     fun calculateCenter160() {
         // setup
-        val frequencyRange = listOf(
-            50 to (5250 to (5170 to 5329)),
-            82 to (5410 to (5330 to 5489)),
-            114 to (5650 to (5490 to 5730)),
-            163 to (5815 to (5735 to 5895)),
-            15 to (6025 to (5945 to 6104)),
-            47 to (6185 to (6105 to 6264)),
-            79 to (6345 to (6265 to 6424)),
-            111 to (6505 to (6425 to 6584)),
-            143 to (6665 to (6585 to 6744)),
-            175 to (6825 to (6745 to 6904)),
-            207 to (6985 to (6905 to 7065))
-        )
-        val frequencyCenter = frequencyRange.map { it.first to it.second.first }
-        val frequencyOutOfRange = listOf(5169, 5731, 5732, 5733, 5734, 5896, 5944, 7066)
+        val expected = 35
         // execute & validate
-        calculateCenterUsingCenter1(frequencyCenter, calculateCenter160)
-        calculateCenterUsingCenter0(frequencyCenter, calculateCenter160)
-        calculateCenterUsingPrimary(frequencyCenter, calculateCenter160)
-        calculateCenterUsingRange(frequencyRange, calculateCenter160, frequencyCenter.map { it.second })
-        calculateCenterUsingOutOfRange(frequencyOutOfRange, calculateCenter160)
+        assertThat(calculateCenter160(0, 0, expected)).isEqualTo(expected)
+        assertThat(calculateCenter160(0, Int.MIN_VALUE, expected)).isEqualTo(expected)
+        assertThat(calculateCenter160(0, Int.MAX_VALUE, expected)).isEqualTo(expected)
+        assertThat(calculateCenter160(Int.MIN_VALUE, 0, expected)).isEqualTo(expected)
+        assertThat(calculateCenter160(Int.MAX_VALUE, 0, expected)).isEqualTo(expected)
+        assertThat(calculateCenter160(Int.MIN_VALUE, Int.MIN_VALUE, expected)).isEqualTo(expected)
+        assertThat(calculateCenter160(Int.MAX_VALUE, Int.MAX_VALUE, expected)).isEqualTo(expected)
     }
 
     @Test
     fun calculateCenter320() {
         // setup
-        val frequencyRange = listOf(
-            31 to (6100 to (5945 to 6264)),
-            95 to (6430 to (6265 to 6584)),
-            159 to (6750 to (6585 to 6904)),
-            191 to (6910 to (6905 to 7065))
-        )
-        val frequencyCenter = listOf(31 to 6100, 63 to 6270, 95 to 6430, 127 to 6590, 159 to 6750, 191 to 6910)
-        val frequencyOutOfRange = listOf(5944, 7066)
+        val expected = 35
         // execute & validate
-        calculateCenterUsingCenter1(frequencyCenter, calculateCenter320)
-        calculateCenterUsingCenter0(frequencyCenter, calculateCenter320)
-        calculateCenterUsingPrimary(frequencyCenter, calculateCenter320)
-        calculateCenterUsingRange(frequencyRange, calculateCenter320, frequencyCenter.map { it.second })
-        calculateCenterUsingOutOfRange(frequencyOutOfRange, calculateCenter320)
+        assertThat(calculateCenter320(0, 0, expected)).isEqualTo(expected)
+        assertThat(calculateCenter320(0, Int.MIN_VALUE, expected)).isEqualTo(expected)
+        assertThat(calculateCenter320(0, Int.MAX_VALUE, expected)).isEqualTo(expected)
+        assertThat(calculateCenter320(Int.MIN_VALUE, 0, expected)).isEqualTo(expected)
+        assertThat(calculateCenter320(Int.MAX_VALUE, 0, expected)).isEqualTo(expected)
+        assertThat(calculateCenter320(Int.MIN_VALUE, Int.MIN_VALUE, expected)).isEqualTo(expected)
+        assertThat(calculateCenter320(Int.MAX_VALUE, Int.MAX_VALUE, expected)).isEqualTo(expected)
     }
 
-    /**
-     * parameters:
-     * frequencyCenter: list of channel and frequency center
-     * calculateCenter: function to calculate center
-     */
-    private fun calculateCenterUsingCenter1(frequencyCenter: List<Pair<Int, Int>>, calculateCenter: CalculateCenter) {
-        frequencyCenter.forEach { (channel, expected) ->
-            // execute
-            val actualCenter1 = calculateCenter(0, 0, expected)
-            // validate
-            assertThat(actualCenter1).describedAs("channel: $channel | frequency: $expected").isEqualTo(expected)
-        }
-    }
-
-    /**
-     * parameters:
-     * frequencyCenter: list of channel and frequency center
-     * calculateCenter: function to calculate center
-     */
-    private fun calculateCenterUsingCenter0(frequencyCenter: List<Pair<Int, Int>>, calculateCenter: CalculateCenter) {
-        frequencyCenter.forEach { (channel, expected) ->
-            // execute
-            val actualCenter0 = calculateCenter(0, expected, 0)
-            // validate
-            assertThat(actualCenter0).describedAs("channel: $channel | frequency: $expected").isEqualTo(expected)
-        }
-    }
-
-    /**
-     * parameters:
-     * frequencyCenter: list of channel and frequency center
-     * calculateCenter: function to calculate center
-     */
-    private fun calculateCenterUsingPrimary(frequencyCenter: List<Pair<Int, Int>>, calculateCenter: CalculateCenter) {
-        frequencyCenter.forEach { (channel, expected) ->
-            // execute
-            val actualPrimary = calculateCenter(expected, 0, 0)
-            // validate
-            assertThat(actualPrimary).describedAs("channel: $channel | frequency: $expected").isEqualTo(expected)
-        }
-    }
-
-    /**
-     * parameters:
-     * frequencyRange: list of channel, frequency center, frequency range
-     * calculateCenter: function to calculate center
-     * frequencyCenter: list of frequency center
-     */
-    private fun calculateCenterUsingRange(
-        frequencyRange: List<Pair<Int, Pair<Int, Pair<Int, Int>>>>,
-        calculateCenter: CalculateCenter,
-        frequencyCenter: List<Int>
-    ) {
-        frequencyRange.forEach { (channel, frequencyAndRange) ->
-            val (expected, range) = frequencyAndRange
-            (range.first..range.second)
-                .filter { it !in frequencyCenter }
-                .forEach {
-                    // execute
-                    val actualPrimary = calculateCenter(it, 0, 0)
-                    // validate
-                    assertThat(actualPrimary).describedAs("channel: $channel | frequency: $it").isEqualTo(expected)
-                }
-        }
-    }
-
-    /**
-     * parameters:
-     * outOfRangeFrequencies: list of out of range frequencies
-     * calculateCenter: function to calculate center
-     */
-    private fun calculateCenterUsingOutOfRange(outOfRangeFrequencies: List<Int>, calculateCenter: CalculateCenter) {
-        outOfRangeFrequencies.forEach { frequency ->
-            // setup
-            val expected = 111
-            // execute
-            val actualPrimary = calculateCenter(frequency, 0, expected)
-            // validate
-            assertThat(actualPrimary).describedAs("frequency: $frequency").isEqualTo(expected)
-        }
-    }
 }