Android 12: Fix retrieval without using WiFiManager.getConnectionInfo

Author: TheNodi

src/main/java/net/kuama/wifiMonitor/WifiMonitor.kt

@@ -21,11 +21,11 @@ class WifiMonitor private constructor(
         private var listener: WifiListener? = null
         fun listener(listener: WifiListener) = apply { this.listener = listener }
 
-        private fun listenerBuilder(): WifiListener =
+        private fun listenerBuilder(wifiManager: WifiManager): WifiListener =
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                AndroidQWifiListener()
+                AndroidQWifiListener(wifiManager)
             } else {
-                BeforeAndroidQWifiListener()
+                BeforeAndroidQWifiListener(wifiManager)
             }
 
         private var wifiManager: WifiManager? = null
@@ -38,12 +38,15 @@ class WifiMonitor private constructor(
 
         private fun permissionCheckerBuilder(context: Context): PermissionChecker = PermissionChecker.Builder().context(context).build()
 
-        fun build(context: Context): WifiMonitor = WifiMonitor(
-            context = context,
-            listener = listener ?: listenerBuilder(),
-            wifiManager = wifiManager ?: wifiManagerBuilder(context),
-            permissionChecker = permissionChecker ?: permissionCheckerBuilder(context),
-        )
+        fun build(context: Context): WifiMonitor {
+            val wifiManager = wifiManager ?: wifiManagerBuilder(context)
+            return WifiMonitor(
+                context = context,
+                listener = listener ?: listenerBuilder(wifiManager),
+                wifiManager = wifiManager,
+                permissionChecker = permissionChecker ?: permissionCheckerBuilder(context),
+            )
+        }
     }
 
     /**
@@ -62,7 +65,8 @@ class WifiMonitor private constructor(
                 State.DISCONNECTED
             )
             WifiManager.WIFI_STATE_ENABLED -> {
-                val connectionInfo = wifiInfo ?: @Suppress("DEPRECATION") wifiManager.connectionInfo
+                val connectionInfo = wifiInfo ?: return@map WifiStatus(State.UNKNOWN)
+
                 WifiStatus(
                     state = if (isFineLocationAccessGranted) State.CONNECTED else State.CONNECTED_MISSING_FINE_LOCATION_PERMISSION,
                     ssid = connectionInfo.ssid,

src/main/java/net/kuama/wifiMonitor/implementation/AndroidQWifiListener.kt

@@ -5,8 +5,8 @@ import android.content.Context
 import android.net.ConnectivityManager
 import android.net.Network
 import android.net.NetworkCapabilities
-import android.net.NetworkRequest
 import android.net.wifi.WifiInfo
+import android.net.wifi.WifiManager
 import android.os.Build
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.channels.awaitClose
@@ -24,31 +24,41 @@ import net.kuama.wifiMonitor.WifiListener
  * From now on, to observe connectivity changes we should register a [ConnectivityManager.NetworkCallback] implementation.
  */
 @TargetApi(Build.VERSION_CODES.Q)
-internal class AndroidQWifiListener : WifiListener {
+internal class AndroidQWifiListener(private val wifiManager: WifiManager) : WifiListener {
     @OptIn(ExperimentalCoroutinesApi::class)
     override fun listen(context: Context): Flow<WifiInfo?> = callbackFlow {
-        val callback = object : ConnectivityManager.NetworkCallback() {
-            override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
-                super.onCapabilitiesChanged(network, networkCapabilities)
+        // Android 12 requires a new flag to receive SSID data, but flag-based constructor has been introduced only in SDK 31.
+        val networkCallback = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
+            object : ConnectivityManager.NetworkCallback(FLAG_INCLUDE_LOCATION_INFO) {
+                override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
+                    super.onCapabilitiesChanged(network, networkCapabilities)
 
-                val wifiInfo = networkCapabilities.transportInfo as WifiInfo
-                @Suppress("BlockingMethodInNonBlockingContext")
-                trySendBlocking(wifiInfo)
-            }
-        }
+                    trySendBlocking(networkCapabilities.transportInfo as? WifiInfo?)
+                }
+            } else
+            object : ConnectivityManager.NetworkCallback() {
+                override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
+                    super.onCapabilitiesChanged(network, networkCapabilities)
 
-        val request = NetworkRequest.Builder()
-            .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
-            .build()
+                    // There's a weird behavior in SDK 30 where transportInfo is null even when connected to the WiFi.
+                    // Fallback to soon-to-deprecate connectionInfo if we're connected to a WiFi network.
+                    @Suppress("DEPRECATION")
+                    val wifiInfo =
+                        (networkCapabilities.transportInfo as? WifiInfo?)
+                            ?: if (wifiManager.wifiState == WifiManager.WIFI_STATE_ENABLED) wifiManager.connectionInfo else null
+
+                    trySendBlocking(wifiInfo)
+                }
+            }
 
         val connectivityManager = context.applicationContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
 
         // Register the callback on network changes.
-        connectivityManager.registerNetworkCallback(request, callback)
+        connectivityManager.registerDefaultNetworkCallback(networkCallback)
 
         // Wait for flow cancellation, then unregister the callback.
         awaitClose {
-            connectivityManager.unregisterNetworkCallback(callback)
+            connectivityManager.unregisterNetworkCallback(networkCallback)
         }
     }
 }

src/main/java/net/kuama/wifiMonitor/implementation/BeforeAndroidQWifiListener.kt

@@ -5,6 +5,7 @@ import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
 import android.net.wifi.WifiInfo
+import android.net.wifi.WifiManager
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.channels.trySendBlocking
@@ -17,13 +18,13 @@ import net.kuama.wifiMonitor.WifiListener
  *
  * Before Android Q we can register an intent receiver to observe wifi state changes.
  */
-internal class BeforeAndroidQWifiListener : WifiListener {
+internal class BeforeAndroidQWifiListener(private val wifiManager: WifiManager) : WifiListener {
     @OptIn(ExperimentalCoroutinesApi::class)
     override fun listen(context: Context): Flow<WifiInfo?> = callbackFlow {
         val receiver = object : BroadcastReceiver() {
             override fun onReceive(context: Context?, intent: Intent?) {
-                @Suppress("BlockingMethodInNonBlockingContext")
-                trySendBlocking(null)
+                @Suppress("DEPRECATION")
+                trySendBlocking(if (wifiManager.wifiState == WifiManager.WIFI_STATE_ENABLED) wifiManager.connectionInfo else null)
             }
         }
 

src/test/java/net/kuama/wifiMonitor/WifiMonitorTest.kt

@@ -7,15 +7,15 @@ import io.mockk.mockk
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flowOf
-import kotlinx.coroutines.test.runBlockingTest
+import kotlinx.coroutines.test.runTest
 import net.kuama.wifiMonitor.data.WifiStatus
 import org.junit.Test
 
 @OptIn(ExperimentalCoroutinesApi::class)
 class WifiMonitorTest {
     @Test
     fun `it sends a wifi status disconnected in the flow when wifi manager is receiving a disabled state`() =
-        runBlockingTest {
+        runTest {
             // Arrange
             val context = mockk<Context>(relaxed = true)
             val wifiManager = mockk<WifiManager>(relaxed = true)