Fix connection bar not updating live on connectivity change

Fix 2 re-queried ConnectivityManager.getActiveNetwork() in onLost to avoid
misreporting a network handover as a disconnect. On real devices getActiveNetwork()
can still return the network being torn down at that instant, so a genuine
disconnect was suppressed by the de-dupe, leaving wasConnected stuck true. The
"No connection" bar then only updated on the next onResume poll, not live.

Track the set of available internet-capable networks instead (registerNetworkCallback
with a NET_CAPABILITY_INTERNET request): a handover adds the replacement before
removing the old network so the set never empties (no false disconnect), while a
real disconnect empties it reliably. Removes the fragile getActiveNetwork() query.

Author: nbradbury

WordPress/src/main/java/org/wordpress/android/networking/NetworkConnectionMonitor.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import android.net.ConnectivityManager
 import android.net.Network
 import android.net.NetworkCapabilities
+import android.net.NetworkRequest
 import android.os.Handler
 import android.os.HandlerThread
 import org.greenrobot.eventbus.EventBus
@@ -13,21 +14,25 @@ import javax.inject.Inject
 import javax.inject.Singleton
 
 /**
- * Global monitor for changes to the device's default network connectivity.
+ * Global monitor for changes to the device's network connectivity.
  *
  * Uses [ConnectivityManager.NetworkCallback] registered on a background [HandlerThread] rather than the
  * deprecated CONNECTIVITY_ACTION broadcast. Because a NetworkCallback is not a broadcast it is not subject to
  * background-broadcast ANR timeouts, and all connectivity work runs off the main thread. A
  * [ConnectionChangeEvent] is posted on EventBus whenever the connected state changes; EventBus marshals the
  * `onEventMainThread` subscribers back onto the main thread.
+ *
+ * Connectivity is tracked as the set of currently-available internet-capable networks rather than a single
+ * network. During a handover (e.g. Wi-Fi -> cellular) the replacement is added before the old one is removed,
+ * so the set never empties and the handover is not misreported as a disconnection; a genuine disconnect
+ * empties the set and is reported reliably.
  */
 @Singleton
 class NetworkConnectionMonitor @Inject constructor() {
     private var started = false
     private var wasConnected = false
     private var isFirstCallback = true
-
-    private var connectivityManager: ConnectivityManager? = null
+    private val availableNetworks = mutableSetOf<Network>()
 
     class ConnectionChangeEvent(val isConnected: Boolean)
 
@@ -36,23 +41,28 @@ class NetworkConnectionMonitor @Inject constructor() {
         if (started) return
         val manager = context.applicationContext
             .getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager ?: return
-        connectivityManager = manager
 
         val thread = HandlerThread("NetworkConnectionMonitor").apply { start() }
         val callback = object : ConnectivityManager.NetworkCallback() {
-            override fun onAvailable(network: Network) = onConnectivityChanged(true)
-            // onLost fires for the network that was lost, but during a handover (e.g. Wi-Fi -> cellular) the
-            // new default has already arrived via onAvailable, so re-query rather than assuming we're offline.
-            override fun onLost(network: Network) = onConnectivityChanged(hasActiveConnection())
+            override fun onAvailable(network: Network) {
+                availableNetworks.add(network)
+                onConnectivityChanged(availableNetworks.isNotEmpty())
+            }
+            override fun onLost(network: Network) {
+                availableNetworks.remove(network)
+                onConnectivityChanged(availableNetworks.isNotEmpty())
+            }
         }
-        manager.registerDefaultNetworkCallback(callback, Handler(thread.looper))
+        val request = NetworkRequest.Builder()
+            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+            .build()
+        manager.registerNetworkCallback(request, callback, Handler(thread.looper))
         started = true
     }
 
     /**
      * Called on the monitor's background thread. Posts a [ConnectionChangeEvent] on the first callback and
-     * whenever the connected state actually changes, so subscribers aren't spammed when a network's
-     * capabilities change without a change in availability.
+     * whenever the connected state actually changes, so subscribers aren't spammed while connectivity churns.
      */
     private fun onConnectivityChanged(isConnected: Boolean) {
         if (isFirstCallback || isConnected != wasConnected) {
@@ -62,14 +72,4 @@ class NetworkConnectionMonitor @Inject constructor() {
             EventBus.getDefault().post(ConnectionChangeEvent(isConnected))
         }
     }
-
-    /**
-     * Whether there is currently a default network capable of reaching the internet. Used to distinguish a
-     * true disconnection from a handover between networks, where the replacement is already the default.
-     */
-    private fun hasActiveConnection(): Boolean {
-        val manager = connectivityManager ?: return false
-        val capabilities = manager.activeNetwork?.let { manager.getNetworkCapabilities(it) }
-        return capabilities?.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) == true
-    }
 }