refactor code for improved readability

Author: VREMSoftwareDevelopment

app/build.properties

@@ -1,6 +1,6 @@
 #Build Properties
-#Mon Mar 31 20:38:21 EDT 2025
-version_build=4
+#Wed Apr 02 19:13:56 EDT 2025
+version_build=5
 version_major=3
 version_minor=2
 version_patch=0

app/src/main/kotlin/com/vrem/wifianalyzer/Configuration.kt

@@ -26,6 +26,5 @@ const val SIZE_MAX = 4096
 class Configuration(val largeScreen: Boolean) {
     var size = SIZE_MAX
 
-    val sizeAvailable: Boolean
-        get() = size == SIZE_MAX
+    val sizeAvailable: Boolean get() = size == SIZE_MAX
 }

app/src/main/kotlin/com/vrem/wifianalyzer/MainContext.kt

@@ -44,17 +44,13 @@ enum class MainContext {
     lateinit var configuration: Configuration
     lateinit var filtersAdapter: FiltersAdapter
 
-    val context: Context
-        get() = mainActivity.applicationContext
+    val context: Context get() = mainActivity.applicationContext
 
-    val resources: Resources
-        get() = context.resources
+    val resources: Resources get() = context.resources
 
-    val layoutInflater: LayoutInflater
-        get() = mainActivity.layoutInflater
+    val layoutInflater: LayoutInflater get() = mainActivity.layoutInflater
 
-    private val wiFiManager: WifiManager
-        get() = context.getSystemService(Context.WIFI_SERVICE) as WifiManager
+    private val wiFiManager: WifiManager get() = context.getSystemService(Context.WIFI_SERVICE) as WifiManager
 
     fun initialize(activity: MainActivity, largeScreen: Boolean) {
         mainActivity = activity

app/src/main/kotlin/com/vrem/wifianalyzer/navigation/items/NavigationItem.kt

@@ -23,8 +23,6 @@ import com.vrem.wifianalyzer.navigation.NavigationMenu
 
 interface NavigationItem {
     fun activate(mainActivity: MainActivity, menuItem: MenuItem, navigationMenu: NavigationMenu)
-    val registered: Boolean
-        get() = false
-    val visibility: Int
-        get() = android.view.View.GONE
+    val registered: Boolean get() = false
+    val visibility: Int get() = android.view.View.GONE
 }

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/accesspoint/ConnectionViewType.kt

@@ -25,6 +25,5 @@ enum class ConnectionViewType(@LayoutRes val layout: Int) {
     COMPACT(R.layout.access_point_view_compact),
     HIDE(R.layout.access_point_view_hide);
 
-    val hide: Boolean
-        get() = HIDE == this
+    val hide: Boolean get() = HIDE == this
 }

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

@@ -25,20 +25,14 @@ import java.util.Locale
 class WiFiChannelCountry(val locale: Locale) {
     private val unknown = "-Unknown"
 
-    val countryCode: String
-        get() = locale.country.toCapitalize(locale)
+    val countryCode: String get() = locale.country.toCapitalize(locale)
 
     fun countryName(currentLocale: Locale): String {
         val countryName: String = locale.getDisplayCountry(currentLocale)
         return if (locale.country == countryName) countryName + unknown else countryName
     }
 
-    fun channels(wiFiBand: WiFiBand): List<Int> {
-        val wiFiChannels = wiFiBand.wiFiChannels
-        return wiFiChannels.availableChannels
-            .subtract(wiFiChannels.excludeChannels.flatMap { it[countryCode] ?: emptyList() })
-            .toList()
-    }
+    fun channels(wiFiBand: WiFiBand): List<Int> = wiFiBand.wiFiChannels.ratingChannels(wiFiBand, countryCode)
 
     companion object {
         fun find(countryCode: String): WiFiChannelCountry = WiFiChannelCountry(findByCountryCode(countryCode))

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

@@ -20,23 +20,22 @@ package com.vrem.wifianalyzer.wifi.band
 import com.vrem.util.EMPTY
 import com.vrem.wifianalyzer.wifi.model.WiFiWidth
 
+typealias RatingChannels = (wiFiBand: WiFiBand, countryCode: String) -> List<Int>
+
 class WiFiChannels(
     val channelRange: WiFiChannelPair,
     val offset: Int,
     val activeChannels: Map<WiFiWidth, List<Int>>,
     val graphChannels: Map<Int, String>,
     val availableChannels: List<Int>,
-    val excludeChannels: List<Map<String, List<Int>>> = listOf()
+    val ratingChannels: RatingChannels
 ) {
 
     fun availableChannels(wiFiBand: WiFiBand, countryCode: String): List<WiFiChannel> =
         WiFiChannelCountry.find(countryCode).channels(wiFiBand).map { wiFiChannelByChannel(it) }
 
-    fun availableChannels(wiFiWidth: WiFiWidth, countryCode: String): List<Int> =
-        activeChannels[wiFiWidth]
-            .orEmpty()
-            .subtract(excludeChannels.flatMap { it[countryCode] ?: emptyList() })
-            .toList()
+    fun availableChannels(wiFiWidth: WiFiWidth, wiFiBand: WiFiBand, countryCode: String): List<Int> =
+        activeChannels[wiFiWidth].orEmpty().filter { it in ratingChannels(wiFiBand, countryCode) }
 
     fun inRange(frequency: Int): Boolean = frequency in channelRange.first.frequency..channelRange.second.frequency
 
@@ -66,4 +65,5 @@ class WiFiChannels(
         val channel = ((frequency - channelRange.first.frequency) / FREQUENCY_SPREAD + firstChannel).toInt()
         return WiFiChannel(channel, frequency)
     }
+
 }

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

@@ -57,6 +57,13 @@ private val countriesETSI = listOf(
     "IL"
 )
 
+private val countriesNA = listOf("AS", "CA", "CO", "DO", "FM", "GT", "GU", "MP", "MX", "PA", "PR", "UM", "US", "UZ", "VI")
+
+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 excludeGHZ5: List<Map<String, List<Int>>> =
     countriesETSI.map { mapOf(it to listOf(177)) } +
         listOf(
@@ -82,18 +89,33 @@ private val excludeGHZ5: List<Map<String, List<Int>>> =
         ).map { mapOf(it.first to it.second) }
 
 private val excludeGHZ6: List<Map<String, List<Int>>> =
-    (countriesETSI + listOf("JP", "RU", "NZ", "AU", "GL", "AE", "GB", "MX", "SG", "HK", "MO", "PH"))
-        .map { mapOf(it to (97..223).toList()) }
+    (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 }
+}
+
+private val ratingChannelsGHZ5: RatingChannels = { wiFiBand, countryCode ->
+    val excludedChannels = excludeGHZ5.flatMap { it[countryCode] ?: emptyList() }
+    wiFiBand.wiFiChannels.availableChannels.filterNot { it in excludedChannels }
+}
+
+private val ratingChannelsGHZ6: RatingChannels = { wiFiBand, countryCode ->
+    val excludedChannels = excludeGHZ6.flatMap { it[countryCode] ?: emptyList() }
+    wiFiBand.wiFiChannels.availableChannels.filterNot { it in excludedChannels }
+}
 
 internal val wiFiChannelsGHZ2 = WiFiChannels(
     WiFiChannelPair(WiFiChannel(-1, 2402), WiFiChannel(15, 2482)),
     1,
     mapOf(
-        WiFiWidth.MHZ_20 to listOf(1, 2, 3, 6, 7, 8, 11, 12, 13),
-        WiFiWidth.MHZ_40 to listOf(3, 7, 11)
+        WiFiWidth.MHZ_20 to listOf(1, 5, 6, 9, 13).toList(),
+        WiFiWidth.MHZ_40 to listOf(3, 11).toList(),
     ),
     (1..13).associateWith { "$it" },
-    listOf(1, 2, 3, 6, 7, 8, 11, 12, 13)
+    listOf(1, 3, 5, 6, 9, 11, 13),
+    ratingChannelsGHZ2
 )
 
 internal val wiFiChannelsGHZ5 = WiFiChannels(
@@ -113,9 +135,13 @@ internal val wiFiChannelsGHZ5 = WiFiChannels(
             else -> "$it"
         }
     },
-    ((42..138 step WiFiWidth.MHZ_80.step) + (155..171 step WiFiWidth.MHZ_80.step) +
-        (50..114 step WiFiWidth.MHZ_160.step) + 163).toSortedSet().toList(),
-    excludeGHZ5
+    ((32..144 step WiFiWidth.MHZ_20.step) + (149..177 step WiFiWidth.MHZ_20.step) +
+        (38..142 step WiFiWidth.MHZ_40.step) + (151..175 step WiFiWidth.MHZ_40.step) +
+        (42..138 step WiFiWidth.MHZ_80.step) + (155..171 step WiFiWidth.MHZ_80.step) +
+        (50..114 step WiFiWidth.MHZ_160.step) + 163)
+        .toSortedSet()
+        .toList(),
+    ratingChannelsGHZ5
 )
 
 internal val wiFiChannelsGHZ6 = WiFiChannels(
@@ -137,6 +163,12 @@ internal val wiFiChannelsGHZ6 = WiFiChannels(
             else -> "$it"
         }
     },
-    ((15..207 step WiFiWidth.MHZ_160.step) + (31..191 step WiFiWidth.MHZ_320.step)).toSortedSet().toList(),
-    excludeGHZ6
+    ((1..233 step WiFiWidth.MHZ_20.step) +
+        (3..227 step WiFiWidth.MHZ_40.step) +
+        (7..215 step WiFiWidth.MHZ_80.step) +
+        (15..207 step WiFiWidth.MHZ_160.step) +
+        (31..191 step WiFiWidth.MHZ_320.step))
+        .toSortedSet()
+        .toList(),
+    ratingChannelsGHZ6
 )

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/channelavailable/ChannelAvailableFragment.kt

@@ -58,7 +58,7 @@ class ChannelAvailableFragment : Fragment() {
             channelsAvailableCountryCode.text = countryCode
             channelsAvailableCountryName.text = WiFiChannelCountry.find(countryCode).countryName(languageLocale)
             textViews.forEach { (textView, wiFiBand, wiFiWidth) ->
-                textView.text = wiFiBand.wiFiChannels.availableChannels(wiFiWidth, countryCode).joinToString(", ")
+                textView.text = wiFiBand.wiFiChannels.availableChannels(wiFiWidth, wiFiBand, countryCode).joinToString(", ")
             }
         }
     }

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/graphutils/GraphViewBuilder.kt

@@ -137,11 +137,9 @@ class GraphViewBuilder(
         return this
     }
 
-    val numVerticalLabels: Int
-        get() = (maximumPortY - MIN_Y) / 10 + 1
+    val numVerticalLabels: Int get() = (maximumPortY - MIN_Y) / 10 + 1
 
-    val maximumPortY: Int
-        get() = if (maximumY > MAX_Y || maximumY < MIN_Y_HALF) MAX_Y_DEFAULT else maximumY
+    val maximumPortY: Int get() = if (maximumY > MAX_Y || maximumY < MIN_Y_HALF) MAX_Y_DEFAULT else maximumY
 
     val layoutParams: ViewGroup.LayoutParams =
         ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/graphutils/GraphViewWrapper.kt

@@ -99,8 +99,7 @@ class GraphViewWrapper(
         viewport.setMaxX(maxX.toDouble())
     }
 
-    val viewportCntX: Int
-        get() = graphView.gridLabelRenderer.numHorizontalLabels - 1
+    val viewportCntX: Int get() = graphView.gridLabelRenderer.numHorizontalLabels - 1
 
     fun addSeries(series: BaseSeries<GraphDataPoint>) {
         graphView.addSeries(series)

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

@@ -21,9 +21,7 @@ import com.vrem.annotation.OpenClass
 import com.vrem.wifianalyzer.wifi.band.WiFiChannel
 
 @OpenClass
-class ChannelRating {
-    private val wiFiDetails: MutableList<WiFiDetail> = mutableListOf()
-
+class ChannelRating(val wiFiDetails: MutableList<WiFiDetail> = mutableListOf()) {
     fun count(wiFiChannel: WiFiChannel): Int = collectOverlapping(wiFiChannel).size
 
     fun strength(wiFiChannel: WiFiChannel): Strength =
@@ -34,11 +32,9 @@ class ChannelRating {
                 .maxByOrNull { it } ?: Strength.ZERO.ordinal
         ]
 
-    fun wiFiDetails(): List<WiFiDetail> = wiFiDetails
-
-    fun wiFiDetails(wiFiDetails: List<WiFiDetail>) {
-        this.wiFiDetails.clear()
-        this.wiFiDetails.addAll(removeSame(wiFiDetails))
+    fun wiFiDetails(newWiFiDetails: List<WiFiDetail>) {
+        wiFiDetails.clear()
+        wiFiDetails.addAll(removeSame(newWiFiDetails))
     }
 
     fun bestChannels(wiFiChannels: List<WiFiChannel>): List<ChannelAPCount> =

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

@@ -31,7 +31,6 @@ enum class GroupBy(val sort: Comparator<WiFiDetail>, val group: GroupByKey<WiFiD
     CHANNEL(sortByChannel(), groupByChannel),
     VIRTUAL(sortBySSID(), groupByVirtual);
 
-    val none: Boolean
-        get() = NONE == this
+    val none: Boolean get() = NONE == this
 
 }

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

@@ -27,8 +27,7 @@ data class WiFiConnection(
 ) :
     Comparable<WiFiConnection> {
 
-    val connected: Boolean
-        get() = EMPTY != this
+    val connected: Boolean get() = EMPTY != this
 
     override fun equals(other: Any?): Boolean {
         if (this === other) return true

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

@@ -31,8 +31,7 @@ data class WiFiDetail(
     constructor(wiFiDetail: WiFiDetail, children: List<WiFiDetail>) :
         this(wiFiDetail.wiFiIdentifier, wiFiDetail.wiFiSecurity, wiFiDetail.wiFiSignal, wiFiDetail.wiFiAdditional, children)
 
-    val noChildren: Boolean
-        get() = children.isNotEmpty()
+    val noChildren: Boolean get() = children.isNotEmpty()
 
     override fun equals(other: Any?): Boolean {
         if (this === other) return true

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

@@ -29,8 +29,7 @@ data class WiFiIdentifier(val ssidRaw: SSID = String.EMPTY, val bssid: BSSID = S
         else -> ssidRaw
     }
 
-    val title: String
-        get() = "$ssid ($bssid)"
+    val title: String get() = "$ssid ($bssid)"
 
     fun equals(other: WiFiIdentifier, ignoreCase: Boolean = false): Boolean =
         ssid.equals(other.ssidRaw, ignoreCase) && bssid.equals(other.bssid, ignoreCase)

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

@@ -83,18 +83,12 @@ enum class WiFiSecurityType(
 
 data class WiFiSecurity(val capabilities: String = String.EMPTY, val securityTypes: List<Int> = listOf()) {
 
-    val security: Security
-        get() = securities.first()
+    val security: Security get() = securities.first()
 
     val securities: Set<Security>
-        get() {
-            return (transformCapabilities() + transformSecurityTypes()).toSortedSet().ifEmpty { setOf(Security.NONE) }
-        }
-
-    val wiFiSecurityTypes: Set<WiFiSecurityType>
-        get() {
-            return WiFiSecurityType.findAll(securityTypes)
-        }
+        get() = (transformCapabilities() + transformSecurityTypes()).toSortedSet().ifEmpty { setOf(Security.NONE) }
+
+    val wiFiSecurityTypes: Set<WiFiSecurityType> get() = WiFiSecurityType.findAll(securityTypes)
 
     fun wiFiSecurityTypesDisplay(context: Context): String =
         wiFiSecurityTypes

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

@@ -51,23 +51,17 @@ data class WiFiSignal(
 
     val wiFiBand: WiFiBand = WiFiBand.find(primaryFrequency)
 
-    val wiFiChannelStart: WiFiChannel
-        get() = wiFiBand.wiFiChannels.wiFiChannelByFrequency(centerFrequency - wiFiWidth.frequencyWidthHalf)
+    val wiFiChannelStart: WiFiChannel get() = wiFiBand.wiFiChannels.wiFiChannelByFrequency(centerFrequency - wiFiWidth.frequencyWidthHalf)
 
-    val wiFiChannelEnd: WiFiChannel
-        get() = wiFiBand.wiFiChannels.wiFiChannelByFrequency(centerFrequency + wiFiWidth.frequencyWidthHalf)
+    val wiFiChannelEnd: WiFiChannel get() = wiFiBand.wiFiChannels.wiFiChannelByFrequency(centerFrequency + wiFiWidth.frequencyWidthHalf)
 
-    val primaryWiFiChannel: WiFiChannel
-        get() = wiFiBand.wiFiChannels.wiFiChannelByFrequency(primaryFrequency)
+    val primaryWiFiChannel: WiFiChannel get() = wiFiBand.wiFiChannels.wiFiChannelByFrequency(primaryFrequency)
 
-    val centerWiFiChannel: WiFiChannel
-        get() = wiFiBand.wiFiChannels.wiFiChannelByFrequency(centerFrequency)
+    val centerWiFiChannel: WiFiChannel get() = wiFiBand.wiFiChannels.wiFiChannelByFrequency(centerFrequency)
 
-    val strength: Strength
-        get() = Strength.calculate(level)
+    val strength: Strength get() = Strength.calculate(level)
 
-    val distance: String
-        get() = String.format("~%.1fm", calculateDistance(primaryFrequency, level))
+    val distance: String get() = String.format("~%.1fm", calculateDistance(primaryFrequency, level))
 
     fun inRange(frequency: Int): Boolean =
         frequency in wiFiChannelStart.frequency..wiFiChannelEnd.frequency

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

@@ -21,8 +21,7 @@ package com.vrem.wifianalyzer.wifi.model
 private const val BSSID_LENGTH = 17
 
 data class WiFiVirtual(val bssid: String, val frequency: Int) {
-    val key: String
-        get() = "$bssid-$frequency"
+    val key: String get() = "$bssid-$frequency"
 }
 
 val WiFiDetail.wiFiVirtual: WiFiVirtual

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

@@ -78,14 +78,11 @@ internal class Cache {
             .coerceIn(LEVEL_MINIMUM, LEVEL_MAXIMUM)
     }
 
-    private fun combineCache(): List<ScanResult> =
-        scanResults.flatten().sortedWith(comparator())
+    private fun combineCache(): List<ScanResult> = scanResults.flatten().sortedWith(comparator())
 
-    private fun comparator(): Comparator<ScanResult> =
-        compareBy<ScanResult> { it.BSSID }.thenBy { it.ssid() }.thenBy { it.level }
+    private fun comparator(): Comparator<ScanResult> = compareBy<ScanResult> { it.BSSID }.thenBy { it.ssid() }.thenBy { it.level }
 
-    private val sizeAvailable: Boolean
-        get() = MainContext.INSTANCE.configuration.sizeAvailable
+    private val sizeAvailable: Boolean get() = MainContext.INSTANCE.configuration.sizeAvailable
 
     companion object {
         private const val MINIMUM: Int = 1

app/src/main/kotlin/com/vrem/wifianalyzer/wifi/timegraph/TimeGraphCache.kt

@@ -43,7 +43,6 @@ internal class TimeGraphCache {
         if (notSeen[wiFiDetail] != null) notSeen[wiFiDetail] = 0
     }
 
-    val wiFiDetails: Set<WiFiDetail>
-        get() = notSeen.keys
+    val wiFiDetails: Set<WiFiDetail> get() = notSeen.keys
 
 }