Remove `GetCurrentLocation`.

Make the daemon send two tunnel state updates, one with out IP being
empty, and another with it being filled when am.i.mullvad.net responds.

Update CLI for this change. Other front ends are left out.

2 files changed, 44 insertions, 44 deletions

diff --git a/mullvad-cli/src/cmds/status.rs b/mullvad-cli/src/cmds/status.rs
index a4a8add15e..f833868516 100644
--- a/mullvad-cli/src/cmds/status.rs
+++ b/mullvad-cli/src/cmds/status.rs
@@ -18,10 +18,7 @@ pub struct StatusArgs {
     #[arg(long, short = 'v')]
     verbose: bool,
 
-    /// Print the current location and IP, based on GeoIP lookups
-    #[arg(long, short = 'l')]
-    location: bool,
-
+    // TODO: changelog about removing location flag
     /// Enable debug output
     #[arg(long, short = 'd')]
     debug: bool,
@@ -29,22 +26,29 @@ pub struct StatusArgs {
 
 impl Status {
     pub async fn listen(mut rpc: MullvadProxyClient, args: StatusArgs) -> Result<()> {
+        let mut previous_tunnel_state = None;
+
         while let Some(event) = rpc.events_listen().await?.next().await {
             match event? {
                 DaemonEvent::TunnelState(new_state) => {
                     if args.debug {
                         println!("New tunnel state: {new_state:#?}");
                     } else {
-                        format::print_state(&new_state, args.verbose);
-                    }
-
-                    match new_state {
-                        TunnelState::Connected { .. } | TunnelState::Disconnected => {
-                            if args.location {
-                                print_location(&mut rpc).await?;
-                            }
+                        // When we enter the connected or disconnected state, am.i.mullvad.net will
+                        // be polled to get IP information. When it arrives, we will get another
+                        // tunnel state of the same enum type, but with the IP  filled in. This
+                        // match statement checks for duplicate tunnel states and skips the second
+                        // print to avoid spamming the user.
+                        match (&previous_tunnel_state, &new_state) {
+                            (Some(TunnelState::Disconnected(_)), TunnelState::Disconnected(_))
+                            | (
+                                Some(TunnelState::Connected { .. }),
+                                TunnelState::Connected { .. },
+                            ) => continue,
+                            _ => {}
                         }
-                        _ => {}
+                        format::print_state(&new_state, args.verbose);
+                        previous_tunnel_state = Some(new_state);
                     }
                 }
                 DaemonEvent::Settings(settings) => {
@@ -88,11 +92,9 @@ pub async fn handle(cmd: Option<Status>, args: StatusArgs) -> Result<()> {
     if args.debug {
         println!("Tunnel state: {state:#?}");
     } else {
+        // TODO: respect location arg?
         format::print_state(&state, args.verbose);
-    }
-
-    if args.location {
-        print_location(&mut rpc).await?;
+        format::print_location(&state);
     }
 
     if cmd == Some(Status::Listen) {
@@ -101,31 +103,6 @@ pub async fn handle(cmd: Option<Status>, args: StatusArgs) -> Result<()> {
     Ok(())
 }
 
-async fn print_location(rpc: &mut MullvadProxyClient) -> Result<()> {
-    let location = match rpc.get_current_location().await {
-        Ok(location) => location,
-        Err(error) => match &error {
-            mullvad_management_interface::Error::NoLocationData => {
-                println!("Location data unavailable");
-                return Ok(());
-            }
-            _ => return Err(error.into()),
-        },
-    };
-    if let Some(ipv4) = location.ipv4 {
-        println!("IPv4: {ipv4}");
-    }
-    if let Some(ipv6) = location.ipv6 {
-        println!("IPv6: {ipv6}");
-    }
-
-    println!(
-        "Position: {:.5}°N, {:.5}°W",
-        location.latitude, location.longitude
-    );
-    Ok(())
-}
-
 fn print_account_loggedout(state: &TunnelState, device: &DeviceState) {
     match state {
         TunnelState::Connecting { .. } | TunnelState::Connected { .. } | TunnelState::Error(_) => {
@@ -137,6 +114,6 @@ fn print_account_loggedout(state: &TunnelState, device: &DeviceState) {
                 DeviceState::LoggedIn(_) => (),
             }
         }
-        TunnelState::Disconnected | TunnelState::Disconnecting(_) => (),
+        TunnelState::Disconnected(_) | TunnelState::Disconnecting(_) => (),
     }
 }
diff --git a/mullvad-cli/src/format.rs b/mullvad-cli/src/format.rs
index 2938842cef..0e920b6218 100644
--- a/mullvad-cli/src/format.rs
+++ b/mullvad-cli/src/format.rs
@@ -37,11 +37,34 @@ pub fn print_state(state: &TunnelState, verbose: bool) {
                 format_relay_connection(endpoint, location.as_ref(), verbose)
             );
         }
-        Disconnected => println!("Disconnected"),
+        Disconnected(_) => {
+            println!("Disconnected");
+        }
         Disconnecting(_) => println!("Disconnecting..."),
     }
 }
 
+pub fn print_location(state: &TunnelState) {
+    let location = match state {
+        TunnelState::Disconnected(location) => location,
+        TunnelState::Connected { location, .. } => location,
+        _ => return,
+    };
+    if let Some(location) = location {
+        print!("Your connection appears from: {}", location.country);
+        if let Some(city) = &location.city {
+            print!(", {}", city);
+        }
+        if let Some(ipv4) = location.ipv4 {
+            print!(". IPv4: {ipv4}");
+        }
+        if let Some(ipv6) = location.ipv6 {
+            print!(", IPv6: {ipv6}");
+        }
+        println!();
+    }
+}
+
 fn format_relay_connection(
     endpoint: &TunnelEndpoint,
     location: Option<&GeoIpLocation>,