Fixes based on feedback

Author: Pururun

android/lib/talpid/src/main/kotlin/net/mullvad/talpid/ConnectivityListener.kt

@@ -21,7 +21,7 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.scan
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.plus
-import net.mullvad.talpid.model.ConnectionStatus
+import net.mullvad.talpid.model.Connectivity
 import net.mullvad.talpid.util.IPAvailabilityUtils
 import net.mullvad.talpid.util.NetworkEvent
 import net.mullvad.talpid.util.defaultNetworkFlow
@@ -31,7 +31,7 @@ class ConnectivityListener(
     val connectivityManager: ConnectivityManager,
     val protect: (socket: DatagramSocket) -> Unit,
 ) {
-    private lateinit var _isConnected: StateFlow<ConnectionStatus>
+    private lateinit var _isConnected: StateFlow<Connectivity>
     // Used by JNI
     val isConnected
         get() = _isConnected.value
@@ -50,23 +50,23 @@ class ConnectivityListener(
                     linkPropertiesChanged: NetworkEvent,
                     hasInternetCapability: Boolean ->
                     if (hasInternetCapability) {
-                        ConnectionStatus(
+                        Connectivity.Status(
                                 IPAvailabilityUtils.isIPv4Available(protect = { protect(it) }),
                                 IPAvailabilityUtils.isIPv6Available(protect = { protect(it) }),
                             )
                             // If we have internet, but both IPv4 and IPv6 are not available, we
                             // assume something is wrong and instead
                             // will return both as available since this is the previous behavior.
-                            .takeUnless { !it.ipv4 && !it.ipv6 } ?: ConnectionStatus(true, true)
+                            .takeUnless { !it.ipv4 && !it.ipv6 } ?: Connectivity.Status(true, true)
                     } else {
-                        ConnectionStatus(false, false)
+                        Connectivity.Status(false, false)
                     }
                 }
                 .onEach { notifyConnectivityChange(it.ipv4, it.ipv6) }
                 .stateIn(
                     scope + Dispatchers.IO,
                     SharingStarted.Eagerly,
-                    ConnectionStatus(false, false),
+                    Connectivity.Status(false, false),
                 )
     }
 

android/lib/talpid/src/main/kotlin/net/mullvad/talpid/model/ConnectionStatus.kt

@@ -0,0 +1,7 @@
+package net.mullvad.talpid.model
+
+sealed class Connectivity {
+    data class Status(val ipv4: Boolean, val ipv6: Boolean) : Connectivity()
+
+    data object PresumeOnline : Connectivity()
+}

android/lib/talpid/src/main/kotlin/net/mullvad/talpid/model/Connectivity.kt

@@ -14,10 +14,13 @@ object IPAvailabilityUtils {
         isIPAvailable(InetAddress.getByName(PUBLIC_IPV6_ADDRESS), protect)
 
     // Fake a connection to a public ip address using a UDP socket.
+    // We don't care about the result of the connection, only that it is possible to create.
+    // This is done this way since otherwise there is not way to check the availability of an ip
+    // version on the underlying network if the VPN is turned on.
     // Since we are protecting the socket it will use the underlying network regardless
     // if the VPN is turned on or not.
     // If the ip version is not supported on the underlying network it will trigger a socket
-    // exception. If not it should return the local ip address.
+    // exception. Otherwise we assume it is available.
     private inline fun <reified T : InetAddress> isIPAvailable(
         ip: T,
         protect: (socket: DatagramSocket) -> Unit,
@@ -26,7 +29,7 @@ object IPAvailabilityUtils {
         return try {
             protect(socket)
             socket.connect(InetSocketAddress(ip, 1))
-            socket.localAddress.hostAddress?.isNotEmpty() == true && socket.localAddress is T
+            true
         } catch (_: SocketException) {
             Logger.e("Socket could not be set up")
             false

android/lib/talpid/src/main/kotlin/net/mullvad/talpid/util/IPAvailabilityUtils.kt

@@ -16,5 +16,6 @@ pub const CLASSES: &[&str] = &[
     "net/mullvad/talpid/ConnectivityListener",
     "net/mullvad/talpid/TalpidVpnService",
     "net/mullvad/mullvadvpn/lib/endpoint/ApiEndpointOverride",
-    "net/mullvad/talpid/model/ConnectionStatus",
+    "net/mullvad/talpid/model/Connectivity$Status",
+    "net/mullvad/talpid/model/Connectivity$PresumeOnline",
 ];

mullvad-jni/src/classes.rs

@@ -82,7 +82,7 @@ impl ConnectivityListener {
         };
 
         Ok(ConnectivityListener {
-            jvm: android_context.clone().jvm,
+            jvm: android_context.jvm,
             android_listener,
         })
     }
@@ -98,18 +98,16 @@ impl ConnectivityListener {
 
     /// Return the current offline/connectivity state
     pub fn connectivity(&self) -> Connectivity {
-        self.get_is_connected()
-            .map(|(ipv4, ipv6)| Connectivity::Status { ipv4, ipv6 })
-            .unwrap_or_else(|error| {
-                log::error!(
-                    "{}",
-                    error.display_chain_with_msg("Failed to check connectivity status")
-                );
-                Connectivity::PresumeOnline
-            })
+        self.get_is_connected().unwrap_or_else(|error| {
+            log::error!(
+                "{}",
+                error.display_chain_with_msg("Failed to check connectivity status")
+            );
+            Connectivity::PresumeOnline
+        })
     }
 
-    fn get_is_connected(&self) -> Result<(bool, bool), Error> {
+    fn get_is_connected(&self) -> Result<Connectivity, Error> {
         let env = JnixEnv::from(
             self.jvm
                 .attach_current_thread_as_daemon()
@@ -120,26 +118,14 @@ impl ConnectivityListener {
             .call_method(
                 self.android_listener.as_obj(),
                 "isConnected",
-                "()Lnet/mullvad/talpid/model/ConnectionStatus;",
+                "()Lnet/mullvad/talpid/model/Connectivity;",
                 &[],
             )
             .expect("Missing isConnected")
             .l()
             .expect("isConnected is not an object");
 
-        let ipv4 = env
-            .call_method(is_connected, "component1", "()Z", &[])
-            .expect("Missing ConnectionStatus.ipv4")
-            .z()
-            .expect("ipv4 is not a boolean");
-
-        let ipv6 = env
-            .call_method(is_connected, "component2", "()Z", &[])
-            .expect("Missing ConnectionStatus.ipv6")
-            .z()
-            .expect("ipv6 is not a boolean");
-
-        Ok((ipv4, ipv6))
+        Ok(Connectivity::from_java(&env, is_connected))
     }
 
     /// Return the current DNS servers according to Android
@@ -183,13 +169,13 @@ pub extern "system" fn Java_net_mullvad_talpid_ConnectivityListener_notifyConnec
         return;
     };
 
-    let isIPv4 = JNI_TRUE == is_ipv4;
-    let isIPv6 = JNI_TRUE == is_ipv6;
+    let is_ipv4 = JNI_TRUE == is_ipv4;
+    let is_ipv6 = JNI_TRUE == is_ipv6;
 
     if tx
         .unbounded_send(Connectivity::Status {
-            ipv4: isIPv4,
-            ipv6: isIPv6,
+            ipv4: is_ipv4,
+            ipv6: is_ipv6,
         })
         .is_err()
     {

talpid-core/src/connectivity_listener.rs

@@ -1,4 +1,5 @@
 use ipnetwork::{IpNetwork, Ipv4Network, Ipv6Network};
+use jnix::FromJava;
 use obfuscation::ObfuscatorConfig;
 use serde::{Deserialize, Serialize};
 #[cfg(windows)]
@@ -564,7 +565,8 @@ pub fn all_of_the_internet() -> Vec<ipnetwork::IpNetwork> {
 ///
 /// Information about the host's connectivity, such as the preesence of
 /// configured IPv4 and/or IPv6.
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, FromJava)]
+#[jnix(package = "net.mullvad.talpid.model")]
 pub enum Connectivity {
     Status {
         /// Whether IPv4 connectivity seems to be available on the host.