Only perform one location fetch at a time

1 files changed, 39 insertions, 23 deletions

diff --git a/android/src/main/kotlin/net/mullvad/mullvadvpn/dataproxy/LocationInfoCache.kt b/android/src/main/kotlin/net/mullvad/mullvadvpn/dataproxy/LocationInfoCache.kt
index 98e529fbb8..4f5684b157 100644
--- a/android/src/main/kotlin/net/mullvad/mullvadvpn/dataproxy/LocationInfoCache.kt
+++ b/android/src/main/kotlin/net/mullvad/mullvadvpn/dataproxy/LocationInfoCache.kt
@@ -27,18 +27,18 @@ class LocationInfoCache(val daemon: Deferred<MullvadDaemon>) {
             notifyNewLocation()
         }
 
-    fun setState(state: TunnelStateTransition) {
-        activeFetch?.cancel()
-        activeFetch = null
+    var state: TunnelStateTransition = TunnelStateTransition.Disconnected()
+        set(value) {
+            field = value
 
-        when (state) {
-            is TunnelStateTransition.Disconnected -> activeFetch = fetchRealLocation()
-            is TunnelStateTransition.Connecting -> activeFetch = fetchRelayLocation()
-            is TunnelStateTransition.Connected -> activeFetch = fetchRelayLocation()
-            is TunnelStateTransition.Disconnecting -> location = lastKnownRealLocation
-            is TunnelStateTransition.Blocked -> location = null
+            when (value) {
+                is TunnelStateTransition.Disconnected -> fetchLocation()
+                is TunnelStateTransition.Connecting -> fetchLocation()
+                is TunnelStateTransition.Connected -> fetchLocation()
+                is TunnelStateTransition.Disconnecting -> location = lastKnownRealLocation
+                is TunnelStateTransition.Blocked -> location = null
+            }
         }
-    }
 
     fun notifyNewLocation() {
         val location = this.location
@@ -49,24 +49,40 @@ class LocationInfoCache(val daemon: Deferred<MullvadDaemon>) {
         onNewLocation?.invoke(country, city, hostname)
     }
 
-    private fun fetchRealLocation() = GlobalScope.launch(Dispatchers.Main) {
-        var realLocation: GeoIpLocation? = null
-        var remainingAttempts = 10
+    private fun fetchLocation() {
+        val previousFetch = activeFetch
+        val initialState = state
 
-        while (realLocation == null && remainingAttempts > 0) {
-            realLocation = fetchLocation().await()
-            remainingAttempts -= 1
-        }
+        activeFetch = GlobalScope.launch(Dispatchers.Main) {
+            var newLocation: GeoIpLocation? = null
 
-        lastKnownRealLocation = realLocation
-        location = realLocation
-    }
+            previousFetch?.join()
 
-    private fun fetchRelayLocation() = GlobalScope.launch(Dispatchers.Main) {
-        location = fetchLocation().await()
+            while (newLocation == null && shouldRetryFetch() && state == initialState) {
+                newLocation = executeFetch().await()
+            }
+
+            if (newLocation != null && state == initialState) {
+                when (state) {
+                    is TunnelStateTransition.Disconnected -> {
+                        lastKnownRealLocation = newLocation
+                        location = newLocation
+                    }
+                    is TunnelStateTransition.Connecting -> location = newLocation
+                    is TunnelStateTransition.Connected -> location = newLocation
+                }
+            }
+        }
     }
 
-    private fun fetchLocation() = GlobalScope.async(Dispatchers.Default) {
+    private fun executeFetch() = GlobalScope.async(Dispatchers.Default) {
         daemon.await().getCurrentLocation()
     }
+
+    private fun shouldRetryFetch(): Boolean {
+        val state = this.state
+
+        return state is TunnelStateTransition.Disconnected ||
+            state is TunnelStateTransition.Connected
+    }
 }