Refactor channel rating

Author: VREMSoftwareDevelopment

app/build.properties

@@ -1,6 +1,6 @@
 #Build Properties
-#Wed Apr 02 19:13:56 EDT 2025
-version_build=5
+#Sat Apr 05 08:08:52 EDT 2025
+version_build=6
 version_major=3
 version_minor=2
 version_patch=0

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

@@ -61,8 +61,7 @@ private val countriesNA = listOf("AS", "CA", "CO", "DO", "FM", "GT", "GU", "MP",
 
 private val countriesGHZ6 = listOf("JP", "RU", "NZ", "AU", "GL", "AE", "GB", "MX", "SG", "HK", "MO", "PH")
 
-private val channelsWorldGHZ2 = listOf(1, 3, 5, 9, 13)
-private val channelsNAGHZ2 = listOf(1, 3, 6, 9, 11)
+private val excludeGHZ2: List<Map<String, List<Int>>> = countriesNA.map { mapOf(it to listOf(12, 13)) }
 
 private val excludeGHZ5: List<Map<String, List<Int>>> =
     countriesETSI.map { mapOf(it to listOf(177)) } +
@@ -92,8 +91,8 @@ private val excludeGHZ6: List<Map<String, List<Int>>> =
     (countriesETSI + countriesGHZ6).map { mapOf(it to (97..223).toList()) }
 
 private val ratingChannelsGHZ2: RatingChannels = { wiFiBand, countryCode ->
-    val channels = if (countriesNA.contains(countryCode)) channelsNAGHZ2 else channelsWorldGHZ2
-    wiFiBand.wiFiChannels.availableChannels.filter { it in channels }
+    val excludedChannels = excludeGHZ2.flatMap { it[countryCode] ?: emptyList() }
+    wiFiBand.wiFiChannels.availableChannels.filterNot { it in excludedChannels }
 }
 
 private val ratingChannelsGHZ5: RatingChannels = { wiFiBand, countryCode ->
@@ -110,11 +109,11 @@ internal val wiFiChannelsGHZ2 = WiFiChannels(
     WiFiChannelPair(WiFiChannel(-1, 2402), WiFiChannel(15, 2482)),
     1,
     mapOf(
-        WiFiWidth.MHZ_20 to listOf(1, 5, 6, 9, 13).toList(),
-        WiFiWidth.MHZ_40 to listOf(3, 11).toList(),
+        WiFiWidth.MHZ_20 to (1..13).toList(),
+        WiFiWidth.MHZ_40 to listOf(3, 7, 11),
     ),
     (1..13).associateWith { "$it" },
-    listOf(1, 3, 5, 6, 9, 11, 13),
+    (1..13).toList(),
     ratingChannelsGHZ2
 )
 

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/channelrating/ChannelRatingAdapter.kt

@@ -23,12 +23,11 @@ import android.view.View
 import android.view.ViewGroup
 import android.widget.ArrayAdapter
 import android.widget.RatingBar
-import android.widget.TextView
-import androidx.annotation.ColorRes
 import androidx.core.content.ContextCompat
 import com.vrem.util.EMPTY
 import com.vrem.wifianalyzer.MainContext
 import com.vrem.wifianalyzer.R
+import com.vrem.wifianalyzer.databinding.ChannelRatingBestBinding
 import com.vrem.wifianalyzer.databinding.ChannelRatingDetailsBinding
 import com.vrem.wifianalyzer.wifi.band.WiFiBand
 import com.vrem.wifianalyzer.wifi.band.WiFiChannel
@@ -40,13 +39,18 @@ import com.vrem.wifianalyzer.wifi.scanner.UpdateNotifier
 
 class ChannelRatingAdapter(
     context: Context,
-    private val bestChannels: TextView,
-    private val channelRating: ChannelRating = ChannelRating()
+    val channelRatingBest: ChannelRatingBestBinding,
+    val channelRating: ChannelRating = ChannelRating()
 ) :
-    ArrayAdapter<WiFiChannel>(context, R.layout.channel_rating_details, mutableListOf()),
-    UpdateNotifier {
+    ArrayAdapter<WiFiChannel>(context, R.layout.channel_rating_details, mutableListOf()), UpdateNotifier {
 
-    private val maxChannelsToDisplay = 11
+    private val bindingMap = mapOf(
+        WiFiWidth.MHZ_20 to Pair(channelRatingBest.channelRating20, channelRatingBest.channelRatingRatingChannel20),
+        WiFiWidth.MHZ_40 to Pair(channelRatingBest.channelRating40, channelRatingBest.channelRatingRatingChannel40),
+        WiFiWidth.MHZ_80 to Pair(channelRatingBest.channelRating80, channelRatingBest.channelRatingRatingChannel80),
+        WiFiWidth.MHZ_160 to Pair(channelRatingBest.channelRating160, channelRatingBest.channelRatingRatingChannel160),
+        WiFiWidth.MHZ_320 to Pair(channelRatingBest.channelRating320, channelRatingBest.channelRatingRatingChannel320)
+    )
 
     override fun update(wiFiData: WiFiData) {
         val settings = MainContext.INSTANCE.settings
@@ -56,9 +60,7 @@ class ChannelRatingAdapter(
         val predicate: Predicate = wiFiBand.predicate()
         val wiFiDetails: List<WiFiDetail> = wiFiData.wiFiDetails(predicate, SortBy.STRENGTH)
         channelRating.wiFiDetails(wiFiDetails)
-        val bestChannel = bestChannels(wiFiBand, wiFiChannels)
-        bestChannels.text = bestChannel.message
-        bestChannels.setTextColor(ContextCompat.getColor(context, bestChannel.color))
+        bestChannels(wiFiBand, wiFiChannels)
         notifyDataSetChanged()
     }
 
@@ -70,14 +72,13 @@ class ChannelRatingAdapter(
     }
 
     override fun getView(position: Int, view: View?, parent: ViewGroup): View {
-        val mainContext = MainContext.INSTANCE
-        val wiFiBand = mainContext.settings.wiFiBand()
+        val wiFiBand = MainContext.INSTANCE.settings.wiFiBand()
         val binding = view?.let { ChannelRatingAdapterBinding(it) } ?: ChannelRatingAdapterBinding(create(parent))
         getItem(position)?.let { wiFiChannel ->
             val wiFiWidth = wiFiBand.wiFiChannels.wiFiWidthByChannel(wiFiChannel.channel)
             binding.channelRatingChannel.text = wiFiChannel.channel.toString()
             binding.channelRatingAPCount.text = channelRating.count(wiFiChannel).toString()
-            binding.channelRatingWidth.text = ContextCompat.getString(mainContext.context, wiFiWidth.textResource)
+            binding.channelRatingWidth.text = ContextCompat.getString(context, wiFiWidth.textResource)
             ratingBar(wiFiChannel, binding.channelRating)
         }
         return binding.root
@@ -93,16 +94,32 @@ class ChannelRatingAdapter(
         ratingBar.progressTintList = ColorStateList.valueOf(color)
     }
 
-    internal fun bestChannels(wiFiBand: WiFiBand, wiFiChannels: List<WiFiChannel>): Message {
-        val bestChannels: List<Int> = channelRating.bestChannels(wiFiChannels).map { it.wiFiChannel.channel }
-        return if (bestChannels.isNotEmpty()) {
-            Message(bestChannels.joinToString(separator = ", ", limit = maxChannelsToDisplay), R.color.success)
+    internal fun bestChannels(wiFiBand: WiFiBand, wiFiChannels: List<WiFiChannel>) {
+        val channels = channelRating.bestChannels(wiFiBand, wiFiChannels)
+        val channelRatingMessage = channelRatingBest.channelRatingMessage
+        if (channels.isEmpty()) {
+            channelRatingMessage.text = errorMessage(wiFiBand)
+            channelRatingMessage.setTextColor(ContextCompat.getColor(context, R.color.error))
         } else {
-            Message(errorMessage(wiFiBand), R.color.error)
+            channelRatingMessage.text = String.EMPTY
+            channelRatingMessage.setTextColor(ContextCompat.getColor(context, R.color.success))
         }
+        updateChannelRatings(channels)
     }
 
-    internal class Message(val message: String, @ColorRes val color: Int)
+    private fun updateChannelRatings(channelAPCounts: List<ChannelAPCount>) {
+        WiFiWidth.entries.forEach { wiFiWidth ->
+            val channels = channelAPCounts
+                .filter { it.wiFiWidth == wiFiWidth }
+                .map { it.wiFiChannel.channel }
+                .joinToString(",")
+            val visibility = if (channels.isEmpty()) View.GONE else View.VISIBLE
+            bindingMap[wiFiWidth]?.let { (channelRatingView, channelRatingTextView) ->
+                channelRatingView.visibility = visibility
+                channelRatingTextView.text = channels
+            }
+        }
+    }
 
     private fun errorMessage(wiFiBand: WiFiBand): String = with(context.resources) {
         getText(R.string.channel_rating_best_none).toString() +

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/channelrating/ChannelRatingFragment.kt

@@ -22,7 +22,6 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.ListView
-import android.widget.TextView
 import androidx.fragment.app.Fragment
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout.OnRefreshListener
@@ -44,8 +43,7 @@ class ChannelRatingFragment : Fragment(), OnRefreshListener {
             swipeRefreshLayout.isRefreshing = false
             swipeRefreshLayout.isEnabled = false
         }
-        val bestChannels: TextView = binding.channelRatingBest.channelRatingBestChannels
-        channelRatingAdapter = ChannelRatingAdapter(requireActivity(), bestChannels)
+        channelRatingAdapter = ChannelRatingAdapter(requireActivity(), binding.channelRatingBest)
         val listView: ListView = binding.channelRatingRefresh.findViewById(R.id.channelRatingView)
         listView.adapter = channelRatingAdapter
         return binding.root

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

@@ -19,7 +19,7 @@ package com.vrem.wifianalyzer.wifi.model
 
 import com.vrem.wifianalyzer.wifi.band.WiFiChannel
 
-data class ChannelAPCount(val wiFiChannel: WiFiChannel, val count: Int) : Comparable<ChannelAPCount> {
+data class ChannelAPCount(val wiFiChannel: WiFiChannel, val wiFiWidth: WiFiWidth, val count: Int) : Comparable<ChannelAPCount> {
     override fun compareTo(other: ChannelAPCount): Int =
         compareBy<ChannelAPCount> { it.count }.thenBy { it.wiFiChannel }.compare(this, other)
 }

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

@@ -18,6 +18,7 @@
 package com.vrem.wifianalyzer.wifi.model
 
 import com.vrem.annotation.OpenClass
+import com.vrem.wifianalyzer.wifi.band.WiFiBand
 import com.vrem.wifianalyzer.wifi.band.WiFiChannel
 
 @OpenClass
@@ -37,21 +38,20 @@ class ChannelRating(val wiFiDetails: MutableList<WiFiDetail> = mutableListOf())
         wiFiDetails.addAll(removeSame(newWiFiDetails))
     }
 
-    fun bestChannels(wiFiChannels: List<WiFiChannel>): List<ChannelAPCount> =
+    fun bestChannels(wiFiBand: WiFiBand, wiFiChannels: List<WiFiChannel>): List<ChannelAPCount> =
         wiFiChannels
             .filter { bestChannel(it) }
-            .map { ChannelAPCount(it, count(it)) }
+            .map { ChannelAPCount(it, wiFiBand.wiFiChannels.wiFiWidthByChannel(it.channel), count(it)) }
             .sorted()
 
-    private fun removeSame(wiFiDetails: List<WiFiDetail>): List<WiFiDetail> {
-        return wiFiDetails.distinctBy { it.wiFiVirtual }.sortedWith(SortBy.STRENGTH.sort)
-    }
+    private fun removeSame(wiFiDetails: List<WiFiDetail>): List<WiFiDetail> =
+        wiFiDetails.distinctBy { it.wiFiVirtual }.sortedWith(SortBy.STRENGTH.sort)
 
     private fun collectOverlapping(wiFiChannel: WiFiChannel): List<WiFiDetail> =
         wiFiDetails.filter { it.wiFiSignal.inRange(wiFiChannel.frequency) }
 
-    private fun bestChannel(it: WiFiChannel): Boolean {
-        val strength: Strength = strength(it)
+    private fun bestChannel(wiFiChannel: WiFiChannel): Boolean {
+        val strength: Strength = strength(wiFiChannel)
         return Strength.ZERO == strength || Strength.ONE == strength
     }
 

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

@@ -25,7 +25,6 @@ import kotlin.math.abs
 
 private val CHANNEL_WIDTH_320MHZ = if (buildMinVersionT()) ScanResult.CHANNEL_WIDTH_320MHZ else 5
 
-typealias ChannelWidth = Int
 typealias CalculateCenter = (primary: Int, center0: Int, center1: Int) -> Int
 
 internal val calculateCenter40: CalculateCenter = { primary, center0, _ ->
@@ -37,7 +36,7 @@ internal val calculateCenterUsingCenter1: CalculateCenter = { _, _, center1 -> c
 
 enum class WiFiWidth(
     @StringRes val textResource: Int,
-    val channelWidth: ChannelWidth,
+    val channelWidth: Int,
     val frequencyWidth: Int,
     val guardBand: Int,
     val calculateCenter: CalculateCenter,
@@ -47,20 +46,13 @@ enum class WiFiWidth(
     MHZ_40(R.string.wifi_width_40mhz, ScanResult.CHANNEL_WIDTH_40MHZ, 40, 3, calculateCenter40, 8),
     MHZ_80(R.string.wifi_width_80mhz, ScanResult.CHANNEL_WIDTH_80MHZ, 80, 3, calculateCenterUsingCenter0, 16),
     MHZ_160(R.string.wifi_width_160mhz, ScanResult.CHANNEL_WIDTH_160MHZ, 160, 3, calculateCenterUsingCenter1, 32),
-    MHZ_80_PLUS(
-        R.string.wifi_width_80mhz,
-        ScanResult.CHANNEL_WIDTH_80MHZ_PLUS_MHZ,
-        80,
-        3,
-        calculateCenterUsingCenter1,
-        16
-    ),
+    MHZ_80_PLUS(R.string.wifi_width_80mhz, ScanResult.CHANNEL_WIDTH_80MHZ_PLUS_MHZ, 80, 3, calculateCenterUsingCenter1, 16),
     MHZ_320(R.string.wifi_width_320mhz, CHANNEL_WIDTH_320MHZ, 320, 3, calculateCenterUsingCenter1, 32);
 
     val frequencyWidthHalf: Int = frequencyWidth / 2
 
     companion object {
-        fun findOne(channelWidth: ChannelWidth): WiFiWidth =
+        fun findOne(channelWidth: Int): WiFiWidth =
             WiFiWidth.entries.firstOrNull { it.channelWidth == channelWidth } ?: MHZ_20
     }
 }

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/scanner/Transformer.kt

@@ -21,19 +21,7 @@ import android.net.wifi.WifiInfo
 import com.vrem.annotation.OpenClass
 import com.vrem.util.nullToEmpty
 import com.vrem.util.ssid
-import com.vrem.wifianalyzer.wifi.model.FastRoaming
-import com.vrem.wifianalyzer.wifi.model.WiFiConnection
-import com.vrem.wifianalyzer.wifi.model.WiFiData
-import com.vrem.wifianalyzer.wifi.model.WiFiDetail
-import com.vrem.wifianalyzer.wifi.model.WiFiIdentifier
-import com.vrem.wifianalyzer.wifi.model.WiFiSecurity
-import com.vrem.wifianalyzer.wifi.model.WiFiSecurityType
-import com.vrem.wifianalyzer.wifi.model.WiFiSignal
-import com.vrem.wifianalyzer.wifi.model.WiFiSignalExtra
-import com.vrem.wifianalyzer.wifi.model.WiFiStandard
-import com.vrem.wifianalyzer.wifi.model.WiFiWidth
-import com.vrem.wifianalyzer.wifi.model.convertIpV4Address
-import com.vrem.wifianalyzer.wifi.model.convertSSID
+import com.vrem.wifianalyzer.wifi.model.*
 
 @Suppress("DEPRECATION")
 fun WifiInfo.ipV4Address(): Int = ipAddress
@@ -52,26 +40,23 @@ internal class Transformer(private val cache: Cache) {
         }
     }
 
-    internal fun transformCacheResults(): List<WiFiDetail> =
-        cache.scanResults().map { transform(it) }
+    internal fun transformCacheResults(): List<WiFiDetail> = cache.scanResults().map { transform(it) }
 
-    internal fun transformToWiFiData(): WiFiData =
-        WiFiData(transformCacheResults(), transformWifiInfo())
+    internal fun transformToWiFiData(): WiFiData = WiFiData(transformCacheResults(), transformWifiInfo())
 
     private fun transform(cacheResult: CacheResult): WiFiDetail {
         val scanResult = cacheResult.scanResult
-
         val wiFiWidth = WiFiWidth.findOne(scanResult.channelWidth)
-        val centerFrequency =
-            wiFiWidth.calculateCenter(scanResult.frequency, scanResult.centerFreq0, scanResult.centerFreq1)
-        val mc80211 = scanResult.is80211mcResponder
-        val wiFiStandard = WiFiStandard.findOne(scanResult)
-        val fastRoaming = FastRoaming.find(scanResult)
-        val securityTypes = WiFiSecurityType.find(scanResult)
-        val extra = WiFiSignalExtra(mc80211, wiFiStandard, fastRoaming)
-        val wiFiSignal = WiFiSignal(scanResult.frequency, centerFrequency, wiFiWidth, cacheResult.average, extra)
-        val wiFiIdentifier = WiFiIdentifier(scanResult.ssid(), String.nullToEmpty(scanResult.BSSID))
-        val wiFiSecurity = WiFiSecurity(String.nullToEmpty(scanResult.capabilities), securityTypes)
-        return WiFiDetail(wiFiIdentifier, wiFiSecurity, wiFiSignal)
+        return WiFiDetail(
+            WiFiIdentifier(scanResult.ssid(), String.nullToEmpty(scanResult.BSSID)),
+            WiFiSecurity(String.nullToEmpty(scanResult.capabilities), WiFiSecurityType.find(scanResult)),
+            WiFiSignal(
+                scanResult.frequency,
+                wiFiWidth.calculateCenter(scanResult.frequency, scanResult.centerFreq0, scanResult.centerFreq1),
+                wiFiWidth,
+                cacheResult.average,
+                WiFiSignalExtra(scanResult.is80211mcResponder, WiFiStandard.findOne(scanResult), FastRoaming.find(scanResult))
+            )
+        )
     }
 }