NAVAND-552: predownload voice instructions

Author: dzinad

CHANGELOG.md

@@ -37,6 +37,8 @@ Mapbox welcomes participation and contributions from everyone.
 - Fixed an issue with `NavigationView` that caused road label position to not update in some cases. [#6531](https://github.com/mapbox/mapbox-navigation-android/pull/6531)
 - Fixed an issue where `DirectionsResponse#waypoints` list was cleared after a successful non-EV route refresh. [#6539](https://github.com/mapbox/mapbox-navigation-android/pull/6539)
 - Fixed an issue with EV route refresh failing in cases where EV data updates are not provided. Now, the initial parameters from a route request will be used as a fallback. [#6534](https://github.com/mapbox/mapbox-navigation-android/pull/6534)
+- Optimized voice instructions downloading.
+- Fixed an issue where voice instruction was being played too late with low connectivity. 
 
 ## Mapbox Navigation SDK 2.10.0-alpha.1 - 28 October, 2022
 ### Changelog

examples/src/main/java/com/mapbox/navigation/examples/core/MapboxNavigationActivity.kt

@@ -456,6 +456,7 @@ class MapboxNavigationActivity : AppCompatActivity() {
         mapboxNavigation.onDestroy()
         maneuverApi.cancel()
         speechAPI.cancel()
+        speechAPI.destroy()
         voiceInstructionsPlayer.shutdown()
     }
 

examples/src/main/java/com/mapbox/navigation/examples/core/MapboxVoiceActivity.kt

@@ -410,6 +410,7 @@ class MapboxVoiceActivity : AppCompatActivity(), OnMapLongClickListener {
         mapboxReplayer.finish()
         mapboxNavigation.onDestroy()
         speechApi.cancel()
+        speechApi.destroy()
         voiceInstructionsPlayer.shutdown()
     }
 

libnavigation-util/src/main/java/com/mapbox/navigation/utils/internal/Time.kt

@@ -1,12 +1,17 @@
 package com.mapbox.navigation.utils.internal
 
+import java.util.concurrent.TimeUnit
+
 interface Time {
     fun nanoTime(): Long
     fun millis(): Long
+    fun seconds(): Long
 
     object SystemImpl : Time {
         override fun nanoTime(): Long = System.nanoTime()
 
         override fun millis(): Long = System.currentTimeMillis()
+
+        override fun seconds(): Long = TimeUnit.MILLISECONDS.toSeconds(millis())
     }
 }

libnavigation-util/src/test/java/com/mapbox/navigation/utils/internal/TimeTest.kt

@@ -0,0 +1,29 @@
+package com.mapbox.navigation.utils.internal
+
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import kotlin.math.abs
+
+class TimeTest {
+
+    @Test
+    fun seconds() {
+        val tolerance = 1
+        val diff = abs(System.currentTimeMillis() / 1000 - Time.SystemImpl.seconds())
+        assertTrue(diff < tolerance)
+    }
+
+    @Test
+    fun millis() {
+        val tolerance = 100
+        val diff = abs(System.currentTimeMillis() - Time.SystemImpl.millis())
+        assertTrue(diff < tolerance)
+    }
+
+    @Test
+    fun nanoTime() {
+        val tolerance = 100000000
+        val diff = abs(System.nanoTime() - Time.SystemImpl.nanoTime())
+        assertTrue(diff < tolerance)
+    }
+}

libnavui-voice/api/current.txt

@@ -55,6 +55,7 @@ package com.mapbox.navigation.ui.voice.api {
     ctor public MapboxSpeechApi(android.content.Context context, String accessToken, String language);
     method public void cancel();
     method public void clean(com.mapbox.navigation.ui.voice.model.SpeechAnnouncement announcement);
+    method public void destroy();
     method public void generate(com.mapbox.api.directions.v5.models.VoiceInstructions voiceInstruction, com.mapbox.navigation.ui.base.util.MapboxNavigationConsumer<com.mapbox.bindgen.Expected<com.mapbox.navigation.ui.voice.model.SpeechError,com.mapbox.navigation.ui.voice.model.SpeechValue>> consumer);
   }
 

libnavui-voice/src/main/java/com/mapbox/navigation/ui/voice/api/MapboxSpeechApi.kt

@@ -75,6 +75,14 @@ class MapboxSpeechApi @JvmOverloads constructor(
         voiceAPI.clean(announcement)
     }
 
+    /**
+     * The method stops all work related to pre-downloading voice instructions and unregisters
+     * all related callbacks. It should be invoked from `Activity#onDestroy`.
+     */
+    fun destroy() {
+        voiceAPI.destroy()
+    }
+
     @Throws(IllegalStateException::class)
     private suspend fun retrieveVoiceFile(
         voiceInstruction: VoiceInstructions,

…ion/ui/voice/api/MapboxSpeechProvider.kt …ation/ui/voice/api/MapboxSpeechLoader.ktlibnavui-voice/src/main/java/com/mapbox/navigation/ui/voice/api/MapboxSpeechProvider.kt renamed to libnavui-voice/src/main/java/com/mapbox/navigation/ui/voice/api/MapboxSpeechLoader.kt libnavui-voice/src/main/java/com/mapbox/navigation/ui/voice/api/MapboxSpeechProvider.kt renamed to libnavui-voice/src/main/java/com/mapbox/navigation/ui/voice/api/MapboxSpeechLoader.kt

@@ -5,10 +5,13 @@
 package com.mapbox.navigation.ui.voice.api
 
 import android.net.Uri
+import com.mapbox.api.directions.v5.models.VoiceInstructions
 import com.mapbox.bindgen.Expected
 import com.mapbox.bindgen.ExpectedFactory.createError
 import com.mapbox.bindgen.ExpectedFactory.createValue
+import com.mapbox.common.NetworkRestriction
 import com.mapbox.common.ResourceLoadError
+import com.mapbox.common.ResourceLoadFlags
 import com.mapbox.common.ResourceLoadResult
 import com.mapbox.common.ResourceLoadStatus
 import com.mapbox.navigation.base.internal.accounts.UrlSkuTokenProvider
@@ -17,28 +20,88 @@ import com.mapbox.navigation.ui.utils.internal.resource.ResourceLoader
 import com.mapbox.navigation.ui.utils.internal.resource.load
 import com.mapbox.navigation.ui.voice.model.TypeAndAnnouncement
 import com.mapbox.navigation.ui.voice.options.MapboxSpeechApiOptions
+import com.mapbox.navigation.utils.internal.InternalJobControlFactory
+import com.mapbox.navigation.utils.internal.logE
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.cancelChildren
+import kotlinx.coroutines.launch
 import java.net.MalformedURLException
 import java.net.URL
 
-internal class MapboxSpeechProvider(
+internal class MapboxSpeechLoader(
     private val accessToken: String,
     private val language: String,
     private val urlSkuTokenProvider: UrlSkuTokenProvider,
     private val options: MapboxSpeechApiOptions,
-    private val resourceLoader: ResourceLoader
-) {
+    private val resourceLoader: ResourceLoader,
+) : VoiceInstructionsDownloadTriggerObserver {
 
-    suspend fun load(typeAndAnnouncement: TypeAndAnnouncement): Expected<Throwable, ByteArray> {
+    private val currentRequests = mutableSetOf<Long>()
+    private val downloadedInstructions = mutableSetOf<TypeAndAnnouncement>()
+    private val downloadedInstructionsLock = Any()
+    private val defaultScope = InternalJobControlFactory.createDefaultScopeJobControl().scope
+
+    suspend fun load(voiceInstruction: VoiceInstructions): Expected<Throwable, ByteArray> {
         return runCatching {
-            val url = instructionUrl(typeAndAnnouncement.announcement, typeAndAnnouncement.type)
-            val response = resourceLoader.load(url)
+            val typeAndAnnouncement = VoiceInstructionsParser.parse(voiceInstruction)
+                .getValueOrElse { throw it }
+            val request = createRequest(typeAndAnnouncement).apply {
+                networkRestriction = NetworkRestriction.DISALLOW_ALL
+            }
+            val response = resourceLoader.load(request)
             return processResponse(response)
         }.getOrElse {
             createError(it)
         }
     }
 
-    private suspend fun ResourceLoader.load(url: String) = load(ResourceLoadRequest(url))
+    override fun trigger(voiceInstructions: List<VoiceInstructions>) {
+        defaultScope.launch {
+            voiceInstructions.forEach { voiceInstruction ->
+                val typeAndAnnouncement = VoiceInstructionsParser.parse(voiceInstruction).value
+                if (typeAndAnnouncement != null && !hasTypeAndAnnouncement(typeAndAnnouncement)) {
+                    predownload(typeAndAnnouncement)
+                }
+            }
+        }
+    }
+
+    fun cancel() {
+        defaultScope.cancel()
+        currentRequests.forEach { resourceLoader.cancel(it) }
+    }
+
+    private fun hasTypeAndAnnouncement(typeAndAnnouncement: TypeAndAnnouncement): Boolean {
+        synchronized(downloadedInstructionsLock) {
+            return typeAndAnnouncement in downloadedInstructions
+        }
+    }
+
+    private fun predownload(typeAndAnnouncement: TypeAndAnnouncement) {
+        try {
+            val request = createRequest(typeAndAnnouncement)
+            var id: Long? = null
+            id = resourceLoader.load(request) { result ->
+                id?.let { currentRequests.remove(it) }
+                // tilestore thread
+                if (result.isValue) {
+                    synchronized(downloadedInstructionsLock) {
+                        downloadedInstructions.add(typeAndAnnouncement)
+                    }
+                }
+            }
+            currentRequests.add(id)
+        } catch (ex: Throwable) {
+            logE("Failed to download instruction '$typeAndAnnouncement': ${ex.localizedMessage}")
+        }
+    }
+
+    private fun createRequest(typeAndAnnouncement: TypeAndAnnouncement): ResourceLoadRequest {
+        val url = instructionUrl(typeAndAnnouncement.announcement, typeAndAnnouncement.type)
+        return ResourceLoadRequest(url).apply {
+            flags = ResourceLoadFlags.ACCEPT_EXPIRED
+        }
+    }
 
     private fun processResponse(
         response: Expected<ResourceLoadError, ResourceLoadResult>

libnavui-voice/src/main/java/com/mapbox/navigation/ui/voice/api/MapboxVoiceApi.kt

@@ -12,18 +12,21 @@ import java.io.File
  * Implementation of [VoiceApi] allowing you to retrieve voice instructions.
  */
 internal class MapboxVoiceApi(
-    private val speechProvider: MapboxSpeechProvider,
+    private val speechLoader: MapboxSpeechLoader,
     private val speechFileProvider: MapboxSpeechFileProvider
 ) : VoiceApi {
 
+    init {
+        VoiceInstructionsPredownloadHub.register(speechLoader)
+    }
+
     /**
      * Given [VoiceInstructions] the method returns a [File] wrapped inside [VoiceState]
      * @param voiceInstruction VoiceInstructions object representing [VoiceInstructions]
      */
     override suspend fun retrieveVoiceFile(voiceInstruction: VoiceInstructions): VoiceState {
         return runCatching {
-            val typeAndAnnouncement = VoiceInstructionsParser.parse(voiceInstruction).getOrThrow()
-            val blob = speechProvider.load(typeAndAnnouncement).getOrThrow()
+            val blob = speechLoader.load(voiceInstruction).getOrThrow()
             val file = speechFileProvider.generateVoiceFileFrom(blob.inputStream())
             VoiceFile(file)
         }.getOrElse {
@@ -48,6 +51,11 @@ internal class MapboxVoiceApi(
         speechFileProvider.cancel()
     }
 
+    fun destroy() {
+        VoiceInstructionsPredownloadHub.unregister(speechLoader)
+        speechLoader.cancel()
+    }
+
     private fun genericError(voiceInstruction: VoiceInstructions) =
         "Cannot load voice instructions $voiceInstruction"
 

libnavui-voice/src/main/java/com/mapbox/navigation/ui/voice/api/TimeBasedNextVoiceInstructionsProvider.kt

@@ -1,7 +1,5 @@
 package com.mapbox.navigation.ui.voice.api
 
-import com.mapbox.api.directions.v5.models.LegStep
-import com.mapbox.api.directions.v5.models.RouteLeg
 import com.mapbox.api.directions.v5.models.VoiceInstructions
 import com.mapbox.navigation.utils.internal.logW
 
@@ -27,63 +25,42 @@ internal class TimeBasedNextVoiceInstructionsProvider(
             }
 
         val voiceInstructions = mutableListOf<VoiceInstructions>()
-        fillCurrentStepVoiceInstructions(
-            currentStep,
-            progress.stepDistanceRemaining,
-            voiceInstructions
-        )
         var cumulatedTime = progress.stepDurationRemaining
+        val currentStepInstructions = currentStep.voiceInstructions()?.filter { instruction ->
+            val distanceAlongGeometry = instruction.distanceAlongGeometry()
+            distanceAlongGeometry != null
+                && distanceAlongGeometry <= progress.stepDistanceRemaining
+        }
+        if (currentStepInstructions != null) {
+            voiceInstructions.addAll(currentStepInstructions)
+        }
 
-        // fill next steps
         var currentStepIndex = progress.stepIndex
         var currentLegIndex = progress.legIndex
         while (cumulatedTime < observableTimeSeconds) {
-            if (isLastStep(currentStepIndex, legSteps)) {
+            if (currentStepIndex + 1 < (legSteps?.size ?: 0)) {
+                currentStep = legSteps!![currentStepIndex + 1]
+                currentStepIndex++
+            } else {
                 currentStepIndex = 0
-                if (isLastLeg(currentLegIndex, legs)) {
-                    break
-                } else {
+                if (currentLegIndex + 1 < legs.size) {
                     legSteps = legs[currentLegIndex + 1].steps()
                     currentLegIndex++
                     if (legSteps.isNullOrEmpty()) {
                         continue
                     } else {
                         currentStep = legSteps.first()
                     }
+                } else {
+                    break
                 }
-            } else {
-                currentStep = legSteps!![currentStepIndex + 1]
-                currentStepIndex++
             }
             currentStep.voiceInstructions()?.let { voiceInstructions.addAll(it) }
             cumulatedTime += currentStep.duration()
         }
         return voiceInstructions
     }
 
-    private fun fillCurrentStepVoiceInstructions(
-        currentStep: LegStep,
-        stepDistanceRemaining: Double,
-        voiceInstructions: MutableList<VoiceInstructions>
-    ) {
-        val currentStepInstructions = currentStep.voiceInstructions()?.filter { instruction ->
-            val distanceAlongGeometry = instruction.distanceAlongGeometry()
-            distanceAlongGeometry != null &&
-                distanceAlongGeometry <= stepDistanceRemaining
-        }
-        if (currentStepInstructions != null) {
-            voiceInstructions.addAll(currentStepInstructions)
-        }
-    }
-
-    private fun isLastStep(currentStepIndex: Int, legSteps: List<LegStep>?): Boolean {
-        return currentStepIndex + 1 >= (legSteps?.size ?: 0)
-    }
-
-    private fun isLastLeg(currentLegIndex: Int, legs: List<RouteLeg>): Boolean {
-        return currentLegIndex + 1 >= legs.size
-    }
-
     private companion object {
         private const val LOG_CATEGORY = "TimeBasedNextVoiceInstructionsProvider"
     }