NAVAND-777: remove coalescing refresh requests queue

Author: dzinad

instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/RouteRefreshStateTest.kt

@@ -390,19 +390,18 @@ class RouteRefreshStateTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::cla
         mapboxNavigation.refreshRoutesImmediately()
         mapboxNavigation.refreshRoutesImmediately()
         mapboxNavigation.refreshRoutesImmediately()
+        delay(4000)
 
-        waitForRefreshes(2)
+        waitForRefresh()
 
         assertEquals(
             listOf(
                 RouteRefreshExtra.REFRESH_STATE_STARTED,
                 RouteRefreshExtra.REFRESH_STATE_FINISHED_SUCCESS,
-                RouteRefreshExtra.REFRESH_STATE_STARTED,
-                RouteRefreshExtra.REFRESH_STATE_FINISHED_SUCCESS,
             ),
             observer.getStatesSnapshot()
         )
-        assertEquals(2, refreshHandler.handledRequests.size)
+        assertEquals(1, refreshHandler.handledRequests.size)
     }
 
     @Test

libnavigation-core/src/main/java/com/mapbox/navigation/core/routerefresh/RouteRefresherExecutor.kt

@@ -3,8 +3,6 @@ package com.mapbox.navigation.core.routerefresh
 import com.mapbox.navigation.base.route.NavigationRoute
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
 
 internal interface RouteRefresherProgressCallback {
 
@@ -19,22 +17,19 @@ internal class RouteRefresherExecutor(
     private val timeout: Long,
 ) {
 
-    private val mutex = Mutex()
-    private val queue = ArrayDeque<Pair<List<NavigationRoute>, RouteRefresherProgressCallback>>()
+    private var hasCurrentRequest = false
 
     fun postRoutesToRefresh(
         routes: List<NavigationRoute>,
         callback: RouteRefresherProgressCallback
     ) {
-        queue.clear()
-        queue.add(routes to callback)
         scope.launch {
-            mutex.withLock {
-                queue.removeFirstOrNull()?.let {
-                    it.second.onStarted()
-                    val result = routeRefresher.refresh(it.first, timeout)
-                    it.second.onResult(result)
-                }
+            if (!hasCurrentRequest) {
+                hasCurrentRequest = true
+                callback.onStarted()
+                val result = routeRefresher.refresh(routes, timeout)
+                callback.onResult(result)
+                hasCurrentRequest = false
             }
         }
     }

libnavigation-core/src/test/java/com/mapbox/navigation/core/routerefresh/RouteRefresherExecutorTest.kt

@@ -74,53 +74,12 @@ class RouteRefresherExecutorTest {
 
         coroutineRule.testDispatcher.advanceTimeBy(10000)
 
-        coVerifyOrder {
+        coVerify {
             callback.onResult(routeRefresherResult)
-            callback2.onStarted()
-            callback2.onResult(routeRefresherResult2)
-        }
-    }
-
-    @Test
-    fun onlyTwoRequestsCanBeInQueue() = coroutineRule.runBlockingTest {
-        val routes2 = listOf<NavigationRoute>(mockk(), mockk(), mockk())
-        val routes3 = listOf<NavigationRoute>(mockk())
-        val routes4 = listOf<NavigationRoute>(mockk(), mockk())
-        val callback2 = mockk<RouteRefresherProgressCallback>(relaxed = true)
-        val callback3 = mockk<RouteRefresherProgressCallback>(relaxed = true)
-        val callback4 = mockk<RouteRefresherProgressCallback>(relaxed = true)
-
-        coEvery { routeRefresher.refresh(routes, any()) } coAnswers {
-            delay(10000)
-            routeRefresherResult
-        }
-
-        sut.postRoutesToRefresh(routes, callback)
-        sut.postRoutesToRefresh(routes2, callback2)
-        sut.postRoutesToRefresh(routes3, callback3)
-        sut.postRoutesToRefresh(routes4, callback4)
-
-        coroutineRule.testDispatcher.advanceTimeBy(10000)
-
-        coVerify(exactly = 1) {
-            routeRefresher.refresh(routes, timeout)
-            routeRefresher.refresh(routes4, timeout)
-        }
-        coVerify(exactly = 0) {
-            routeRefresher.refresh(routes2, timeout)
-            routeRefresher.refresh(routes3, timeout)
-        }
-        coVerify(exactly = 1) {
-            callback.onStarted()
-            callback.onResult(any())
-            callback4.onStarted()
-            callback4.onResult(any())
         }
         coVerify(exactly = 0) {
             callback2.onStarted()
             callback2.onResult(any())
-            callback3.onStarted()
-            callback3.onResult(any())
         }
     }
 }