Backport Copilot feature to release-v2.7 (#6776)

* cherry-pick #6387

* cherry-pick #6456

* NAVAND-750: introduce HistoryRecordingSessionState

* invoke HistoryRecordingStateChangeObserver#onShouldStartRecording with current state

* [NOT WORKING] HistoryRecorderHandle.buildCompositeRecorder is missing from NN v111 as it was introduced as part of NN v119
add multiple history recorders support (needed for copilot) (#6509)

* bump nn dependency version to 111.1.0

* add copilot feature (#6572)

* follow up to improve copilot kdocs (#6591)

* use mapbox navigation app lifecycle owner instead of process lifecycle owner to support android auto and remove android x lifecycle process dependency not necessary anymore (#6609)

* [copilot] start recording as soon as on should start recording is called to include deferred events as part of the current history file session (#6655)

* [copilot] make sure created from attachments api is the same as startedAt (#6660)

* use either mapbox navigation app lifecycle owner or process lifecycle owner based on if mapbox navigation app is set up or not respectively to support both use cases in which mapbox navigation app is or is not integrated from the client side and add is copilot initialized check to prevent issues if apis are misused (#6690)

* fix conflicts

* fix changelog

Co-authored-by: Dzina Dybouskaya <32109537+dzinad@users.noreply.github.com>
Co-authored-by: Dzina Dybouskaya <dzina.dybouskaya@mapbox.com>

Author: Pablo Guardiola

CHANGELOG.md

@@ -6,6 +6,7 @@ libnavigation-util \
 libnavigator \
 libtrip-notification \
 libnavigation-core \
+libnavigation-copilot \
 
 CORE_MODULES = $(RELEASED_CORE_MODULES)
 
@@ -123,6 +124,7 @@ core-check-api: assemble-core-release
 	./gradlew :libnavigator:checkApi -PhidePackage=com.mapbox.navigation.navigator.internal
 	./gradlew :libtrip-notification:checkApi -PhidePackage=com.mapbox.navigation.trip.notification.internal
 	./gradlew :libnavigation-core:checkApi -PhidePackage=com.mapbox.navigation.core.internal
+	./gradlew :libnavigation-copilot:checkApi -PhidePackage=com.mapbox.navigation.copilot.internal
 
 .PHONY: core-update-api
 core-update-api: assemble-core-release
@@ -133,6 +135,7 @@ core-update-api: assemble-core-release
 	./gradlew :libnavigator:updateApi -PhidePackage=com.mapbox.navigation.navigator.internal
 	./gradlew :libtrip-notification:updateApi -PhidePackage=com.mapbox.navigation.trip.notification.internal
 	./gradlew :libnavigation-core:updateApi -PhidePackage=com.mapbox.navigation.core.internal
+	./gradlew :libnavigation-copilot:updateApi -PhidePackage=com.mapbox.navigation.copilot.internal
 
 .PHONY: assemble-ui-debug
 assemble-ui-debug:

Makefile

@@ -13,7 +13,7 @@ ext {
   // version which we should use in this build
   def mapboxNavigatorVersion = System.getenv("FORCE_MAPBOX_NAVIGATION_NATIVE_VERSION")
   if (mapboxNavigatorVersion == null || mapboxNavigatorVersion == '') {
-      mapboxNavigatorVersion = '111.0.0'
+      mapboxNavigatorVersion = '111.1.0'
   }
   println("Navigation Native version: " + mapboxNavigatorVersion)
 
@@ -37,6 +37,7 @@ ext {
       androidXAnnotationVersion : '1.2.0',
       androidXFragmentVersion   : '1.4.0',
       androidXDataStore         : '1.0.0',
+      androidXWorkManager       : '2.7.1',
       cardViewVersion           : '1.0.0',
       recyclerViewVersion       : '1.1.0',
       materialDesignVersion     : '1.1.0',
@@ -133,11 +134,13 @@ ext {
       androidXFragment          : "androidx.fragment:fragment-ktx:${version.androidXFragmentVersion}",
       androidXArchCoreTesting   : "androidx.arch.core:core-testing:${version.androidXArchCoreVersion}",
       androidXDataStore         : "androidx.datastore:datastore-preferences:${version.androidXDataStore}",
+      androidXWorkManager       : "androidx.work:work-runtime-ktx:${version.androidXWorkManager}",
 
       // lifecycle
       androidXLifecycleRuntime  : "androidx.lifecycle:lifecycle-runtime-ktx:${version.androidXLifecycle}",
       androidXLifecycleLivedata : "androidx.lifecycle:lifecycle-livedata-ktx:${version.androidXLifecycle}",
       androidXLifecycleViewmodel: "androidx.lifecycle:lifecycle-viewmodel-ktx:${version.androidXLifecycle}",
+      androidXLifecycleProcess  : "androidx.lifecycle:lifecycle-process:${version.androidXLifecycle}",
       androidXLifecycleTesting  : "androidx.lifecycle:lifecycle-runtime-testing:${version.androidXLifecycle}",
 
       // square crew

gradle/dependencies.gradle

@@ -53,6 +53,7 @@ def sdkNameMap = [:]
 sdkNameMap["libnavigation-android"] = "mobile-navigation-android"
 sdkNameMap["libnavigation-base"] = "mobile-navigation-base"
 sdkNameMap["libnavigation-core"] = "mobile-navigation-core"
+sdkNameMap["libnavigation-copilot"] = "mobile-navigation-copilot"
 sdkNameMap["libnavigation-metrics"] = "mobile-navigation-metrics"
 sdkNameMap["libnavigator"] = "mobile-navigation-navigator"
 sdkNameMap["libtrip-notification"] = "mobile-navigation-notification"

gradle/publish.gradle

@@ -0,0 +1,135 @@
+package com.mapbox.navigation.instrumentation_tests.core
+
+import android.location.Location
+import com.mapbox.api.directions.v5.models.RouteOptions
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
+import com.mapbox.navigation.base.extensions.applyDefaultNavigationOptions
+import com.mapbox.navigation.base.extensions.applyLanguageAndVoiceUnitOptions
+import com.mapbox.navigation.base.options.NavigationOptions
+import com.mapbox.navigation.base.route.NavigationRoute
+import com.mapbox.navigation.base.route.RouterOrigin
+import com.mapbox.navigation.core.DeveloperMetadata
+import com.mapbox.navigation.core.DeveloperMetadataObserver
+import com.mapbox.navigation.core.MapboxNavigation
+import com.mapbox.navigation.core.MapboxNavigationProvider
+import com.mapbox.navigation.core.directions.session.RoutesExtra
+import com.mapbox.navigation.core.internal.HistoryRecordingSessionState
+import com.mapbox.navigation.core.internal.HistoryRecordingStateChangeObserver
+import com.mapbox.navigation.core.internal.extensions.registerHistoryRecordingStateChangeObserver
+import com.mapbox.navigation.instrumentation_tests.activity.EmptyTestActivity
+import com.mapbox.navigation.instrumentation_tests.utils.MapboxNavigationRule
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.clearNavigationRoutesAndWaitForUpdate
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.routesUpdates
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.sdkTest
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.setNavigationRoutesAndAwaitError
+import com.mapbox.navigation.instrumentation_tests.utils.history.MapboxHistoryTestRule
+import com.mapbox.navigation.instrumentation_tests.utils.routes.MockRoute
+import com.mapbox.navigation.instrumentation_tests.utils.routes.RoutesProvider
+import com.mapbox.navigation.testing.ui.BaseTest
+import com.mapbox.navigation.testing.ui.utils.getMapboxAccessTokenFromResources
+import com.mapbox.navigation.testing.ui.utils.runOnMainSync
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.first
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+@OptIn(ExperimentalPreviewMapboxNavigationAPI::class)
+class CopilotIntegrationTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.java) {
+
+    private lateinit var mapboxNavigation: MapboxNavigation
+    private lateinit var mockRoute: MockRoute
+    private lateinit var routes: List<NavigationRoute>
+
+    @get:Rule
+    val mapboxNavigationRule = MapboxNavigationRule()
+
+    @get:Rule
+    val mapboxHistoryTestRule = MapboxHistoryTestRule()
+
+    override fun setupMockLocation(): Location {
+        mockRoute = RoutesProvider.dc_very_short(activity)
+        routes = NavigationRoute.create(
+            mockRoute.routeResponse,
+            RouteOptions.builder()
+                .applyDefaultNavigationOptions()
+                .applyLanguageAndVoiceUnitOptions(activity)
+                .baseUrl(mockWebServerRule.baseUrl)
+                .coordinatesList(mockRoute.routeWaypoints).build(),
+            RouterOrigin.Offboard
+        )
+        return mockLocationUpdatesRule.generateLocationUpdate {
+            latitude = mockRoute.routeWaypoints.first().latitude()
+            longitude = mockRoute.routeWaypoints.first().longitude()
+        }
+    }
+
+    @Before
+    fun setUp() {
+        runOnMainSync {
+            mapboxNavigation = MapboxNavigationProvider.create(
+                NavigationOptions.Builder(activity)
+                    .accessToken(getMapboxAccessTokenFromResources(activity))
+                    .build()
+            )
+            mapboxHistoryTestRule.historyRecorder = mapboxNavigation.historyRecorder
+        }
+    }
+
+    @Test
+    fun copilotObserverReceivesSameIdsAsDeveloperMetadata() = sdkTest {
+        val collectedDeveloperMetadatas = mutableListOf<DeveloperMetadata>()
+        val developerMetadataObserver = DeveloperMetadataObserver {
+            collectedDeveloperMetadatas.add(it)
+        }
+        val startedSessionObserverIds = mutableListOf<String>()
+        val historyRecordingStateObserver = object : HistoryRecordingStateChangeObserver {
+            override fun onShouldStartRecording(state: HistoryRecordingSessionState) {
+                startedSessionObserverIds.add(state.sessionId)
+            }
+            override fun onShouldStopRecording(state: HistoryRecordingSessionState) {
+            }
+
+            override fun onShouldCancelRecording(state: HistoryRecordingSessionState) {
+            }
+        }
+        mapboxNavigation.registerDeveloperMetadataObserver(developerMetadataObserver)
+        mockWebServerRule.requestHandlers.addAll(mockRoute.mockRequestHandlers)
+        mapboxNavigation.historyRecorder.startRecording()
+        mapboxNavigation.registerHistoryRecordingStateChangeObserver(historyRecordingStateObserver)
+
+        transitionFromIdleToFreeDrive()
+        transitionFromFreeDriveToActiveGuidance()
+        transitionFromActiveGuidanceToFreeDrive()
+        transitionFromFreeDriveToStubActiveGuidanceAndBackToFreeDrive()
+        transitionFromFreeDriveToIdle()
+
+        val collectedIds = collectedDeveloperMetadatas.map { it.copilotSessionId }
+        // first and last are idle: not recorded by HistoryRecordingStateChangeObserver
+        assertEquals(startedSessionObserverIds, collectedIds.drop(1).dropLast(1))
+    }
+
+    private fun transitionFromIdleToFreeDrive() {
+        mapboxNavigation.startTripSession()
+    }
+
+    private suspend fun transitionFromFreeDriveToActiveGuidance() {
+        mapboxNavigation.setNavigationRoutes(routes)
+        mapboxNavigation.routesUpdates()
+            .filter { it.reason == RoutesExtra.ROUTES_UPDATE_REASON_NEW }
+            .first()
+    }
+
+    private suspend fun transitionFromActiveGuidanceToFreeDrive() {
+        mapboxNavigation.clearNavigationRoutesAndWaitForUpdate()
+    }
+
+    private suspend fun transitionFromFreeDriveToStubActiveGuidanceAndBackToFreeDrive() {
+        mapboxNavigation.setNavigationRoutesAndAwaitError(routes, 6)
+    }
+
+    private fun transitionFromFreeDriveToIdle() {
+        mapboxNavigation.stopTripSession()
+    }
+}