update 160/320 center calculations

Author: VREMSoftwareDevelopment

app/build.properties

@@ -1,6 +1,6 @@
 #Build Properties
-#Tue Mar 25 22:38:45 EDT 2025
-version_build=11
+#Thu Mar 27 17:45:38 EDT 2025
+version_build=12
 version_major=3
 version_minor=1
 version_patch=4

app/jacoco.gradle

@@ -70,7 +70,7 @@ task jacocoTestCoverageVerification(type: JacocoCoverageVerification, dependsOn:
             }
             limit {
                 counter = 'BRANCH'
-                minimum = 0.87
+                minimum = 0.88
             }
             limit {
                 counter = 'COMPLEXITY'

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/band/WiFiChannel.kt

@@ -17,6 +17,8 @@
  */
 package com.vrem.wifianalyzer.wifi.band
 
+private const val ALLOWED_RANGE = FREQUENCY_SPREAD / 2
+
 data class WiFiChannel(val channel: Int = 0, val frequency: Int = 0) : Comparable<WiFiChannel> {
     fun inRange(value: Int): Boolean =
         value in frequency - ALLOWED_RANGE..frequency + ALLOWED_RANGE
@@ -26,7 +28,6 @@ data class WiFiChannel(val channel: Int = 0, val frequency: Int = 0) : Comparabl
 
     companion object {
         val UNKNOWN = WiFiChannel()
-        private const val ALLOWED_RANGE = WiFiChannels.FREQUENCY_SPREAD / 2
     }
 
 }

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/band/WiFiChannels.kt

@@ -19,21 +19,59 @@ package com.vrem.wifianalyzer.wifi.band
 
 import com.vrem.util.EMPTY
 
+internal const val FREQUENCY_SPREAD = 5
+
 typealias WiFiRange = Pair<Int, Int>
 typealias WiFiChannelPair = Pair<WiFiChannel, WiFiChannel>
 
-abstract class WiFiChannels(val channelRange: WiFiChannelPair, val graphChannels: Set<Int>) {
+private val channelRangeGHZ2 = WiFiChannelPair(WiFiChannel(-1, 2402), WiFiChannel(15, 2482))
+private val graphChannelsGHZ2 = (1..13).associate { it to "$it" }
+
+class WiFiChannelsGHZ2 : WiFiChannels(channelRangeGHZ2, graphChannelsGHZ2) {
+    override fun availableChannels(countryCode: String): List<WiFiChannel> =
+        availableChannels(WiFiChannelCountry.find(countryCode).channelsGHZ2())
+}
+
+private val channelRangeGHZ5 = WiFiChannelPair(WiFiChannel(30, 5150), WiFiChannel(179, 5895))
+private val graphChannelsGHZ5 = listOf(42, 58, 74, 90, 106, 122, 138, 156, 171).associate {
+    it to when (it) {
+        156 -> "155"
+        else -> "$it"
+    }
+}
+
+class WiFiChannelsGHZ5 : WiFiChannels(channelRangeGHZ5, graphChannelsGHZ5) {
+    override fun availableChannels(countryCode: String): List<WiFiChannel> =
+        availableChannels(WiFiChannelCountry.find(countryCode).channelsGHZ5())
+
+    override fun graphChannelCount(): Int = super.graphChannelCount() / 2
+}
+
+private val channelRangeGHZ6 = WiFiChannelPair(WiFiChannel(-5, 5925), WiFiChannel(235, 7125))
+private val graphChannelsGHZ6 = listOf(15, 47, 79, 110, 142, 174, 208).associate {
+    it to when (it) {
+        110 -> "111"
+        142 -> "143"
+        174 -> "175"
+        208 -> "207"
+        else -> "$it"
+    }
+}
+
+class WiFiChannelsGHZ6 : WiFiChannels(channelRangeGHZ6, graphChannelsGHZ6) {
+    override fun availableChannels(countryCode: String): List<WiFiChannel> =
+        availableChannels(WiFiChannelCountry.find(countryCode).channelsGHZ6())
+
+    override fun graphChannelCount(): Int = super.graphChannelCount() / 2
+}
+
+abstract class WiFiChannels(val channelRange: WiFiChannelPair, val graphChannels: Map<Int, String>) {
     abstract fun availableChannels(countryCode: String): List<WiFiChannel>
-    abstract fun channelAvailable(countryCode: String, channel: Int): Boolean
 
     fun inRange(frequency: Int): Boolean = frequency in channelRange.first.frequency..channelRange.second.frequency
 
     fun wiFiChannelByFrequency(frequency: Int): WiFiChannel =
-        if (inRange(frequency)) {
-            wiFiChannel(frequency, channelRange)
-        } else {
-            WiFiChannel.UNKNOWN
-        }
+        if (inRange(frequency)) wiFiChannel(frequency) else WiFiChannel.UNKNOWN
 
     fun wiFiChannelByChannel(channel: Int): WiFiChannel =
         if (channel in channelRange.first.channel..channelRange.second.channel) {
@@ -42,31 +80,18 @@ abstract class WiFiChannels(val channelRange: WiFiChannelPair, val graphChannels
             WiFiChannel.UNKNOWN
         }
 
-    open fun graphChannelCount(): Int {
-        return channelRange.second.channel - channelRange.first.channel + 1
-    }
+    open fun graphChannelCount(): Int = channelRange.second.channel - channelRange.first.channel + 1
 
-    fun graphChannelByFrequency(frequency: Int): String {
-        val wiFiChannel: WiFiChannel = wiFiChannelByFrequency(frequency)
-        return if (WiFiChannel.UNKNOWN != wiFiChannel && graphChannels.contains(wiFiChannel.channel)) {
-            "${wiFiChannel.channel}"
-        } else {
-            String.EMPTY
-        }
-    }
+    fun graphChannelByFrequency(frequency: Int): String =
+        graphChannels[wiFiChannelByFrequency(frequency).channel] ?: String.EMPTY
 
-    fun availableChannels(channels: Set<Int>): List<WiFiChannel> = channels.map { this.wiFiChannelByChannel(it) }
+    fun availableChannels(channels: Set<Int>): List<WiFiChannel> = channels.map { wiFiChannelByChannel(it) }
 
     fun wiFiChannels(): List<WiFiChannel> = (channelRange.first.channel..channelRange.second.channel).map { wiFiChannelByChannel(it) }
 
-    private fun wiFiChannel(frequency: Int, wiFiChannelPair: WiFiChannelPair): WiFiChannel {
-        val firstChannel: Int = (wiFiChannelPair.first.channel + if (wiFiChannelPair.first.channel < 0) -0.5 else 0.5).toInt()
-        val channel: Int = ((frequency - wiFiChannelPair.first.frequency).toDouble() / FREQUENCY_SPREAD + firstChannel).toInt()
+    private fun wiFiChannel(frequency: Int): WiFiChannel {
+        val firstChannel = (channelRange.first.channel + if (channelRange.first.channel < 0) -0.5 else 0.5).toInt()
+        val channel = ((frequency - channelRange.first.frequency) / FREQUENCY_SPREAD + firstChannel).toInt()
         return WiFiChannel(channel, frequency)
     }
-
-    companion object {
-        internal const val FREQUENCY_SPREAD = 5
-    }
-
 }

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/band/WiFiChannelsGHZ2.kt

@@ -18,45 +18,75 @@
 package com.vrem.wifianalyzer.wifi.model
 
 import android.net.wifi.ScanResult
+import com.vrem.util.buildMinVersionT
 import kotlin.math.abs
 
-typealias ChannelWidth = Int
+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
 
 internal val calculateCenter20: CalculateCenter = { primary, _, _ -> primary }
-
 internal val calculateCenter40: CalculateCenter = { primary, center0, _ ->
-    if (abs(primary - center0) >= WiFiWidth.MHZ_40.frequencyWidthHalf) {
-        (primary + center0) / 2
-    } else {
-        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
-) {
+enum class WiFiWidth(val channelWidth: ChannelWidth, val frequencyWidth: Int, val guardBand: Int, val calculateCenter: CalculateCenter) {
     MHZ_20(ScanResult.CHANNEL_WIDTH_20MHZ, 20, 2, calculateCenter20),
     MHZ_40(ScanResult.CHANNEL_WIDTH_40MHZ, 40, 3, calculateCenter40),
     MHZ_80(ScanResult.CHANNEL_WIDTH_80MHZ, 80, 3, calculateCenter80),
     MHZ_160(ScanResult.CHANNEL_WIDTH_160MHZ, 160, 3, calculateCenter160),
     MHZ_80_PLUS(ScanResult.CHANNEL_WIDTH_80MHZ_PLUS_MHZ, 80, 3, calculateCenter80),
-    MHZ_320(ScanResult.CHANNEL_WIDTH_320MHZ, 320, 3, calculateCenter320);
+    MHZ_320(CHANNEL_WIDTH_320MHZ, 320, 3, calculateCenter320);
 
     val frequencyWidthHalf: Int = frequencyWidth / 2
 
     companion object {
         fun findOne(channelWidth: ChannelWidth): WiFiWidth =
             WiFiWidth.entries.firstOrNull { it.channelWidth == channelWidth } ?: MHZ_20
     }
-}
+}

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/band/WiFiChannelsGHZ5.kt

@@ -22,8 +22,8 @@ import org.junit.Test
 import java.util.SortedSet
 
 class WiFiChannelCountryGHZ2Test {
-    private val channelsSet1: SortedSet<Int> = sortedSetOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
-    private val channelsSet2: SortedSet<Int> = sortedSetOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
+    private val channelsSet1 = (1..11).toList()
+    private val channelsSet2 = channelsSet1.union(12..13).toList()
     private val fixture = WiFiChannelCountryGHZ2()
 
     @Test
@@ -38,7 +38,7 @@ class WiFiChannelCountryGHZ2Test {
             .forEach { validateChannels(channelsSet2, fixture.findChannels(it)) }
     }
 
-    private fun validateChannels(expected: SortedSet<Int>, actual: SortedSet<Int>) {
+    private fun validateChannels(expected: List<Int>, actual: SortedSet<Int>) {
         assertThat(actual).hasSize(expected.size)
         assertThat(actual).containsAll(expected)
     }