graph channel update

Author: VREMSoftwareDevelopment

app/build.properties

@@ -1,6 +1,6 @@
 #Build Properties
-#Sun Mar 23 19:56:25 EDT 2025
-version_build=9
+#Tue Mar 25 22:01:30 EDT 2025
+version_build=10
 version_major=3
 version_minor=1
 version_patch=4

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

@@ -27,12 +27,15 @@ internal val availableGHZ2: Available = { true }
 internal val availableGHZ5: Available = { MainContext.INSTANCE.wiFiManagerWrapper.is5GHzBandSupported() }
 internal val availableGHZ6: Available = { MainContext.INSTANCE.wiFiManagerWrapper.is6GHzBandSupported() }
 
-enum class WiFiBand(
-    @StringRes val textResource: Int,
-    val wiFiChannels: WiFiChannels,
-    val available: Available,
-    val maxX: Int = 9
-) {
+/**
+ * @see <a href="https://en.wikipedia.org/wiki/List_of_WLAN_channels">List of WLAN channels</a>
+ *
+ * WiFi Bands
+ *  2.4GHz: 1, 2412 -> 13, 2472
+ *  5GHz: 36, 5180 -> 177, 5885
+ *  6GHz: 1, 5955 -> 233, 7115
+ */
+enum class WiFiBand(@StringRes val textResource: Int, val wiFiChannels: WiFiChannels, val available: Available) {
     GHZ2(R.string.wifi_band_2ghz, WiFiChannelsGHZ2(), availableGHZ2),
     GHZ5(R.string.wifi_band_5ghz, WiFiChannelsGHZ5(), availableGHZ5),
     GHZ6(R.string.wifi_band_6ghz, WiFiChannelsGHZ6(), availableGHZ6);

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

@@ -61,6 +61,7 @@ private val countriesETSI: Set<String> = setOf(
     "IL"       // ETSI Israel
 )
 
+// FIXME ... Rules are updated
 internal class WiFiChannelCountryGHZ5 {
     private val channelsSet1: Set<Int> = setOf(36, 40, 44, 48, 52, 56, 60, 64)
     private val channelsSet2: Set<Int> = setOf(100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144)

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

@@ -19,6 +19,7 @@ package com.vrem.wifianalyzer.wifi.band
 
 import java.util.SortedSet
 
+// FIXME ... Rules are updated
 internal class WiFiChannelCountryGHZ6 {
 
     fun findChannels(): SortedSet<Int> = sortedSetOf(

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

@@ -17,59 +17,57 @@
  */
 package com.vrem.wifianalyzer.wifi.band
 
+import com.vrem.util.EMPTY
+
 typealias WiFiRange = Pair<Int, Int>
 typealias WiFiChannelPair = Pair<WiFiChannel, WiFiChannel>
 
-abstract class WiFiChannels(private val wiFiRange: WiFiRange, private val wiFiChannelPairs: List<WiFiChannelPair>) {
-    fun inRange(frequency: Int): Boolean =
-        frequency in wiFiRange.first..wiFiRange.second
+abstract class WiFiChannels(val channelRange: WiFiChannelPair, val graphChannels: Set<Int>) {
+    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)) {
-            wiFiChannelPairs.firstOrNull { WiFiChannel.UNKNOWN != wiFiChannel(frequency, it) }
-                ?.let { wiFiChannel(frequency, it) }
-                ?: WiFiChannel.UNKNOWN
+            wiFiChannel(frequency, channelRange)
         } else {
             WiFiChannel.UNKNOWN
         }
 
     fun wiFiChannelByChannel(channel: Int): WiFiChannel =
-        wiFiChannelPairs.firstOrNull { channel >= it.first.channel && channel <= it.second.channel }
-            ?.let { WiFiChannel(channel, it.first.frequency + (channel - it.first.channel) * FREQUENCY_SPREAD) }
-            ?: WiFiChannel.UNKNOWN
-
-    fun wiFiChannelFirst(): WiFiChannel = wiFiChannelPairs[0].first
-
-    fun wiFiChannelLast(): WiFiChannel = wiFiChannelPairs[wiFiChannelPairs.size - 1].second
-
-    fun wiFiChannel(frequency: Int, wiFiChannelPair: WiFiChannelPair): WiFiChannel {
-        val first: WiFiChannel = wiFiChannelPair.first
-        val last: WiFiChannel = wiFiChannelPair.second
-        val channel: Int = ((frequency - first.frequency).toDouble() / FREQUENCY_SPREAD + first.channel + 0.5).toInt()
-        return if (channel >= first.channel && channel <= last.channel)
-            WiFiChannel(channel, frequency)
-        else
+        if (channel in channelRange.first.channel..channelRange.second.channel) {
+            WiFiChannel(channel, channelRange.first.frequency + (channel - channelRange.first.channel) * FREQUENCY_SPREAD)
+        } else {
             WiFiChannel.UNKNOWN
+        }
+
+    open fun graphChannelCount(): Int {
+        return channelRange.second.channel - channelRange.first.channel + 1
     }
 
-    abstract fun availableChannels(countryCode: String): List<WiFiChannel>
-    abstract fun channelAvailable(countryCode: String, channel: Int): Boolean
-    abstract fun wiFiChannelPairs(): List<WiFiChannelPair>
-    
-    fun wiFiChannelByFrequency(frequency: Int, wiFiChannelPair: WiFiChannelPair): WiFiChannel =
-        if (inRange(frequency)) wiFiChannel(frequency, wiFiChannelPair) else WiFiChannel.UNKNOWN
+    fun graphChannelByFrequency(frequency: Int): String {
+        val wiFiChannel: WiFiChannel = wiFiChannelByFrequency(frequency)
+        return if (WiFiChannel.UNKNOWN == wiFiChannel) {
+            String.EMPTY
+        } else {
+            if (graphChannels.contains(wiFiChannel.channel)) "${wiFiChannel.channel}" else String.EMPTY
+        }
+    }
 
     fun availableChannels(channels: Set<Int>): List<WiFiChannel> = channels.map { this.wiFiChannelByChannel(it) }
 
-    fun wiFiChannels(): List<WiFiChannel> = wiFiChannelPairs.flatMap { transform(it) }
+    fun wiFiChannels(): List<WiFiChannel> = (channelRange.first.channel..channelRange.second.channel).map { wiFiChannelByChannel(it) }
 
-    private fun transform(wiFiChannelPair: WiFiChannelPair): List<WiFiChannel> =
-        (wiFiChannelPair.first.channel..wiFiChannelPair.second.channel).map { wiFiChannelByChannel(it) }
+    private fun wiFiChannel(frequency: Int, wiFiChannelPair: WiFiChannelPair): WiFiChannel {
+        val (first, last) = wiFiChannelPair
+        val firstChannel: Int = (first.channel + if (first.channel < 0) -0.5 else 0.5).toInt()
+        val channel: Int = ((frequency - first.frequency).toDouble() / FREQUENCY_SPREAD + firstChannel).toInt()
+        return if (frequency in first.frequency..last.frequency) WiFiChannel(channel, frequency) else WiFiChannel.UNKNOWN
+    }
 
     companion object {
-        const val FREQUENCY_SPREAD = 5
-        const val CHANNEL_OFFSET = 2
-        const val FREQUENCY_OFFSET = FREQUENCY_SPREAD * CHANNEL_OFFSET
+        internal const val FREQUENCY_SPREAD = 5
     }
 
 }

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

@@ -17,21 +17,15 @@
  */
 package com.vrem.wifianalyzer.wifi.band
 
-class WiFiChannelsGHZ2 : WiFiChannels(RANGE, SETS) {
-    override fun wiFiChannelPairs(): List<WiFiChannelPair> = listOf(SET)
-
+class WiFiChannelsGHZ2 : WiFiChannels(channelRange, graphChannels) {
     override fun availableChannels(countryCode: String): List<WiFiChannel> =
         availableChannels(WiFiChannelCountry.find(countryCode).channelsGHZ2())
 
     override fun channelAvailable(countryCode: String, channel: Int): Boolean =
         WiFiChannelCountry.find(countryCode).channelAvailableGHZ2(channel)
 
     companion object {
-        private val RANGE: WiFiRange = WiFiRange(2400, 2499)
-        private val SETS: List<WiFiChannelPair> = listOf(
-            WiFiChannelPair(WiFiChannel(1, 2412), WiFiChannel(13, 2472)),
-            WiFiChannelPair(WiFiChannel(14, 2484), WiFiChannel(14, 2484))
-        )
-        private val SET: WiFiChannelPair = WiFiChannelPair(SETS[0].first, SETS[SETS.size - 1].second)
+        private val channelRange: WiFiChannelPair = WiFiChannelPair(WiFiChannel(-1, 2402), WiFiChannel(15, 2482))
+        private val graphChannels: Set<Int> = (1..13).toSet()
     }
 }

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

@@ -17,20 +17,20 @@
  */
 package com.vrem.wifianalyzer.wifi.band
 
-class WiFiChannelsGHZ5 : WiFiChannels(RANGE, SETS) {
-    override fun wiFiChannelPairs(): List<WiFiChannelPair> = SETS
-
+class WiFiChannelsGHZ5 : WiFiChannels(channelRange, graphChannels) {
     override fun availableChannels(countryCode: String): List<WiFiChannel> =
         availableChannels(WiFiChannelCountry.find(countryCode).channelsGHZ5())
 
     override fun channelAvailable(countryCode: String, channel: Int): Boolean =
         WiFiChannelCountry.find(countryCode).channelAvailableGHZ5(channel)
 
+    override fun graphChannelCount(): Int {
+        return super.graphChannelCount() / 2
+    }
+
     companion object {
-        private val SET1 = WiFiChannelPair(WiFiChannel(36, 5180), WiFiChannel(64, 5320))
-        private val SET2 = WiFiChannelPair(WiFiChannel(100, 5500), WiFiChannel(144, 5720))
-        private val SET3 = WiFiChannelPair(WiFiChannel(149, 5745), WiFiChannel(177, 5885))
-        private val SETS = listOf(SET1, SET2, SET3)
-        private val RANGE = WiFiRange(4900, 5899)
+        private val channelRange = WiFiChannelPair(WiFiChannel(30, 5150), WiFiChannel(179, 5895))
+        private val graphChannels: Set<Int> = setOf(42, 58, 74, 90, 106, 122, 138, 156, 171)
+
     }
 }

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

@@ -17,18 +17,20 @@
  */
 package com.vrem.wifianalyzer.wifi.band
 
-class WiFiChannelsGHZ6 : WiFiChannels(RANGE, SETS) {
-    override fun wiFiChannelPairs(): List<WiFiChannelPair> = SETS
-
+class WiFiChannelsGHZ6 : WiFiChannels(channelRange, graphChannels) {
     override fun availableChannels(countryCode: String): List<WiFiChannel> =
         availableChannels(WiFiChannelCountry.find(countryCode).channelsGHZ6())
 
     override fun channelAvailable(countryCode: String, channel: Int): Boolean =
         WiFiChannelCountry.find(countryCode).channelAvailableGHZ6(channel)
 
+    override fun graphChannelCount(): Int {
+        return super.graphChannelCount() / 2
+    }
+
     companion object {
-        private val SET = WiFiChannelPair(WiFiChannel(1, 5955), WiFiChannel(229, 7095))
-        private val SETS = listOf(SET)
-        private val RANGE = WiFiRange(5925, 7125)
+        private val channelRange = WiFiChannelPair(WiFiChannel(-1, 5945), WiFiChannel(235, 7125))
+        private val graphChannels: Set<Int> = setOf(15, 47, 79, 110, 142, 174, 208)
     }
+
 }

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/channelgraph/ChannelAxisLabel.kt

@@ -21,39 +21,27 @@ import com.jjoe64.graphview.LabelFormatter
 import com.jjoe64.graphview.Viewport
 import com.vrem.util.EMPTY
 import com.vrem.wifianalyzer.wifi.band.WiFiBand
-import com.vrem.wifianalyzer.wifi.band.WiFiChannel
 import com.vrem.wifianalyzer.wifi.graphutils.MAX_Y
 import com.vrem.wifianalyzer.wifi.graphutils.MIN_Y
 
 internal class ChannelAxisLabel(private val wiFiBand: WiFiBand) : LabelFormatter {
     override fun formatLabel(value: Double, isValueX: Boolean): String {
         val valueAsInt = (value + if (value < 0) -0.5 else 0.5).toInt()
         return if (isValueX) {
-            xValue(valueAsInt)
+            wiFiBand.wiFiChannels.graphChannelByFrequency(valueAsInt)
         } else {
             yValue(valueAsInt)
         }
     }
 
-    private fun yValue(value: Int): String {
-        return if (value in (MIN_Y + 1)..MAX_Y) {
+    private fun yValue(value: Int): String =
+        if (value in (MIN_Y + 1)..MAX_Y) {
             "$value"
         } else {
             String.EMPTY
         }
-    }
-
-    private fun xValue(value: Int): String {
-        val wiFiChannel: WiFiChannel = wiFiBand.wiFiChannels.wiFiChannelByFrequency(value)
-        return if (wiFiChannel == WiFiChannel.UNKNOWN) {
-            String.EMPTY
-        } else {
-            "${wiFiChannel.channel}"
-        }
-    }
 
     override fun setViewport(viewport: Viewport) {
         // ignore
     }
-
-}
+}

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/channelgraph/ChannelGraphView.kt

@@ -26,14 +26,7 @@ import com.vrem.wifianalyzer.R
 import com.vrem.wifianalyzer.settings.Settings
 import com.vrem.wifianalyzer.settings.ThemeStyle
 import com.vrem.wifianalyzer.wifi.band.WiFiBand
-import com.vrem.wifianalyzer.wifi.band.WiFiChannels
-import com.vrem.wifianalyzer.wifi.graphutils.GraphDataPoint
-import com.vrem.wifianalyzer.wifi.graphutils.GraphViewBuilder
-import com.vrem.wifianalyzer.wifi.graphutils.GraphViewNotifier
-import com.vrem.wifianalyzer.wifi.graphutils.GraphViewWrapper
-import com.vrem.wifianalyzer.wifi.graphutils.MIN_Y
-import com.vrem.wifianalyzer.wifi.graphutils.THICKNESS_INVISIBLE
-import com.vrem.wifianalyzer.wifi.graphutils.transparent
+import com.vrem.wifianalyzer.wifi.graphutils.*
 import com.vrem.wifianalyzer.wifi.model.WiFiData
 import com.vrem.wifianalyzer.wifi.predicate.Predicate
 import com.vrem.wifianalyzer.wifi.predicate.makeOtherPredicate
@@ -46,17 +39,17 @@ internal fun makeGraphView(
 ): GraphView {
     val resources = mainContext.resources
 
-    return GraphViewBuilder(wiFiBand.maxX, graphMaximumY, themeStyle, true)
+    return GraphViewBuilder(wiFiBand.wiFiChannels.graphChannelCount(), graphMaximumY, themeStyle, true)
         .setLabelFormatter(ChannelAxisLabel(wiFiBand))
         .setVerticalTitle(resources.getString(R.string.graph_axis_y))
         .setHorizontalTitle(resources.getString(R.string.graph_channel_axis_x))
         .build(mainContext.context)
 }
 
-internal fun makeDefaultSeries(frequencyEnd: Int, minX: Int): TitleLineGraphSeries<GraphDataPoint> {
+internal fun makeDefaultSeries(frequencyStart: Int, frequencyEnd: Int): TitleLineGraphSeries<GraphDataPoint> {
     val dataPoints = arrayOf(
-        GraphDataPoint(minX, MIN_Y),
-        GraphDataPoint(frequencyEnd + WiFiChannels.FREQUENCY_OFFSET, MIN_Y)
+        GraphDataPoint(frequencyStart, MIN_Y),
+        GraphDataPoint(frequencyEnd, MIN_Y)
     )
     val series = TitleLineGraphSeries(dataPoints)
     series.color = transparent.primary.toInt()
@@ -73,9 +66,10 @@ internal fun makeGraphViewWrapper(wiFiBand: WiFiBand): GraphViewWrapper {
     val graphViewWrapper = GraphViewWrapper(graphView, settings.channelGraphLegend(), themeStyle)
     configuration.size = graphViewWrapper.size(graphViewWrapper.calculateGraphType())
     val wiFiChannels = wiFiBand.wiFiChannels.wiFiChannels()
-    val minX = wiFiChannels.first().frequency - WiFiChannels.FREQUENCY_OFFSET
-    val maxX = wiFiChannels.last().frequency + WiFiChannels.FREQUENCY_SPREAD
+    val minX = wiFiChannels.first().frequency
+    val maxX = wiFiChannels.last().frequency
     graphViewWrapper.setViewport(minX, maxX)
+    graphViewWrapper.addSeries(makeDefaultSeries(minX, maxX))
     return graphViewWrapper
 }