Add support of Native Telemetry by flag (#4349)

Author: kried

MapboxNavigation.xcodeproj/project.pbxproj

@@ -1,6 +1,33 @@
 import MapboxNavigationNative
 import MapboxDirections
 @_implementationOnly import MapboxCommon_Private
+@_implementationOnly import MapboxNavigationNative_Private
+
+enum RouteChangeReason {
+    /// Clean a route.
+    case cleanUp
+
+    /// Set a new route, use by default.
+    case startNewRoute
+
+    /// Route index changed to an alternative.
+    case switchToAlternative
+
+    /// New route from different starting point to previous destinations.
+    case reroute
+
+    /// Recreate Navigator after losing internet connection.
+    case fallbackToOffline
+
+    /// Recreate Navigator after restoring internet connection.
+    case restoreToOnline
+
+    /// Navigator used offline route and new route is available from the server.
+    case switchToOnline
+
+    /// Fastest Route available (and should be switched),
+    case fastestRouteAvailable
+}
 
 protocol CoreNavigator {
     static var shared: Self { get }
@@ -22,6 +49,7 @@ protocol CoreNavigator {
     func setRoutes(_ routesData: RoutesData,
                    uuid: UUID,
                    legIndex: UInt32,
+                   reason: RouteChangeReason,
                    completion: @escaping (Result<RoutesCoordinator.RoutesResult, Error>) -> Void)
     func setAlternativeRoutes(with routes: [RouteInterface],
                               completion: @escaping (Result<[RouteAlternative], Error>) -> Void)
@@ -30,6 +58,10 @@ protocol CoreNavigator {
 
     func updateLocation(_ location: CLLocation, completion: @escaping (Bool) -> Void)
 
+    func makeTelemetry(eventsMetadataProvider: EventsMetadataInterface) -> Telemetry
+
+    func makeEventsMetadataProvider() -> EventsMetadataProvider
+
     func resume()
     func pause()
 }
@@ -62,14 +94,13 @@ final class Navigator: CoreNavigator {
     }
 
     private lazy var routeCoordinator: RoutesCoordinator = {
-        .init(routesSetupHandler: { [weak self] routesData, legIndex, completion in
+        .init(routesSetupHandler: { [weak self] routesData, legIndex, reason, completion in
 
             let dataParams = routesData.map { SetRoutesDataParams(routes: $0,
                                                                   legIndex: legIndex) }
-            
-            let reason: SetRoutesReason = routesData != nil ? .newRoute : .cleanUp
+
             self?.navigator.setRoutesDataFor(dataParams,
-                                             reason: reason) { [weak self] result in
+                                             reason: reason.navNativeValue) { [weak self] result in
                 if result.isValue(),
                    let routesResult = result.value {
                     Log.info("Navigator has been updated, including \(routesResult.alternatives.count) alternatives.", category: .navigation)
@@ -146,10 +177,12 @@ final class Navigator: CoreNavigator {
         cacheHandle = factory.cacheHandle
         roadGraph = factory.roadGraph
         navigator = factory.navigator
+
         roadObjectStore = RoadObjectStore(navigator.roadObjectStore())
         roadObjectMatcher = RoadObjectMatcher(MapboxNavigationNative.RoadObjectMatcher(cache: cacheHandle))
         rerouteController = RerouteController(navigator, config: NativeHandlersFactory.configHandle())
-        
+        eventAppState = EventAppState()
+
         subscribeNavigator()
         setupAlternativesControllerIfNeeded()
     }
@@ -174,14 +207,22 @@ final class Navigator: CoreNavigator {
         cacheHandle = factory.cacheHandle
         roadGraph = factory.roadGraph
         navigator = factory.navigator
-        
+
         roadObjectStore.native = navigator.roadObjectStore()
         roadObjectMatcher.native = MapboxNavigationNative.RoadObjectMatcher(cache: cacheHandle)
         rerouteController = RerouteController(navigator, config: NativeHandlersFactory.configHandle())
 
         subscribeNavigator()
         setupAlternativesControllerIfNeeded()
     }
+
+    func makeTelemetry(eventsMetadataProvider: EventsMetadataInterface) -> Telemetry {
+        navigator.getTelemetryForEventsMetadataProvider(eventsMetadataProvider)
+    }
+
+    func makeEventsMetadataProvider() -> EventsMetadataProvider {
+        EventsMetadataProvider(appState: eventAppState)
+    }
 
     private weak var navigatorStatusObserver: NavigatorStatusObserver?
     private weak var navigatorFallbackVersionsObserver: NavigatorFallbackVersionsObserver?
@@ -257,6 +298,8 @@ final class Navigator: CoreNavigator {
     private(set) var roadObjectMatcher: RoadObjectMatcher
 
     private var isSubscribedToElectronicHorizon = false
+
+    private var eventAppState: EventAppState
 
     private var electronicHorizonOptions: ElectronicHorizonOptions? {
         didSet {
@@ -282,8 +325,16 @@ final class Navigator: CoreNavigator {
 
     // MARK: - Navigator Updates
 
-    func setRoutes(_ routesData: RoutesData, uuid: UUID, legIndex: UInt32, completion: @escaping (Result<RoutesCoordinator.RoutesResult, Error>) -> Void) {
-        routeCoordinator.beginActiveNavigation(with: routesData, uuid: uuid, legIndex: legIndex, completion: completion)
+    func setRoutes(_ routesData: RoutesData,
+                   uuid: UUID,
+                   legIndex: UInt32,
+                   reason: RouteChangeReason,
+                   completion: @escaping (Result<RoutesCoordinator.RoutesResult, Error>) -> Void) {
+        routeCoordinator.beginActiveNavigation(with: routesData,
+                                               uuid: uuid,
+                                               legIndex: legIndex,
+                                               reason: reason,
+                                               completion: completion)
     }
 
     func setAlternativeRoutes(with routes: [RouteInterface], completion: @escaping (Result<[RouteAlternative], Error>) -> Void) {
@@ -459,3 +510,26 @@ enum NavigatorError: Swift.Error {
     case failedToUpdateRoutes(reason: String)
     case failedToUpdateAlternativeRoutes(reason: String)
 }
+
+extension RouteChangeReason {
+    var navNativeValue: SetRoutesReason {
+        switch self {
+            case .cleanUp:
+                return .cleanUp
+            case .startNewRoute:
+                return .newRoute
+            case .switchToAlternative:
+                return .alternative
+            case .reroute:
+                return .reroute
+            case .fallbackToOffline:
+                return .fallbackToOffline
+            case .restoreToOnline:
+                return .restoreToOnline
+            case .switchToOnline:
+                return .switchToOnline
+            case .fastestRouteAvailable:
+                return .fastestRoute
+        }
+    }
+}

Package.resolved

@@ -6,6 +6,38 @@ import Foundation
  Conforms to the `Codable` protocol, so the application can store the event persistently.
  */
 public class FeedbackEvent: Codable {
+    let contentType: FeedbackContent
+
+    enum FeedbackContent: Codable {
+        case common(FeedbackCommonEvent)
+        case native(FeedbackMetadata)
+    }
+
+    convenience init(eventDetails: NavigationEventDetails) {
+        self.init(contentType: .common(FeedbackCommonEvent(eventDetails: eventDetails)))
+    }
+
+    convenience init(metadata: FeedbackMetadata) {
+        self.init(contentType: .native(metadata))
+    }
+
+    init(contentType: FeedbackContent) {
+        self.contentType = contentType
+    }
+
+    /// :nodoc:
+    public var contents: [String: Any] {
+        switch contentType {
+            case .common(let data):
+                return data.contents
+            case .native(let data):
+                return data.contents
+        }
+    }
+}
+
+// To be removed after only NN Telemetry is used
+class FeedbackCommonEvent: Codable {
     let coreEvent: CoreFeedbackEvent
 
     init(eventDetails: NavigationEventDetails) {
@@ -34,8 +66,7 @@ public class FeedbackEvent: Codable {
         coreEvent.eventDictionary["description"] = description
     }
 
-    /// :nodoc:
-    public var contents: [String: Any] {
+    var contents: [String: Any] {
         coreEvent.eventDictionary
     }
 }

Sources/MapboxCoreNavigation/CoreNavigationNavigator.swift

@@ -0,0 +1,81 @@
+import Foundation
+import CoreLocation
+import MapboxNavigationNative
+@_implementationOnly import MapboxNavigationNative_Private
+
+/// :nodoc:
+@_spi(MapboxInternal)
+public struct FeedbackMetadata {
+    private let userFeedbackHandle: NativeUserFeedbackHandle?
+    private var calculatedUserFeedbackMetadata: UserFeedbackMetadata? = nil
+
+    var userFeedbackMetadata: UserFeedbackMetadata? {
+        calculatedUserFeedbackMetadata ?? userFeedbackHandle?.getMetadata()
+    }
+
+    public let screenshot: String?
+    public var contents: [String: Any] {
+        guard let data = try? JSONEncoder().encode(self),
+              let dictionary = try? JSONSerialization.jsonObject(
+                with: data, options: .allowFragments) as? [String: Any] else {
+            Log.warning("Unable to encode feedback event details", category: .navigation)
+            return [:]
+        }
+        return dictionary
+    }
+
+    init(userFeedbackHandle: NativeUserFeedbackHandle?,
+         screenshot: String?,
+         userFeedbackMetadata: UserFeedbackMetadata? = nil) {
+        self.userFeedbackHandle = userFeedbackHandle
+        self.screenshot = screenshot
+        self.calculatedUserFeedbackMetadata = userFeedbackMetadata
+    }
+}
+
+extension FeedbackMetadata: Codable {
+    fileprivate enum CodingKeys: String, CodingKey {
+        case screenshot
+        case locationsBefore
+        case locationsAfter
+        case step
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        screenshot = try container.decodeIfPresent(String.self, forKey: .screenshot)
+        calculatedUserFeedbackMetadata = try? UserFeedbackMetadata(from: decoder)
+        userFeedbackHandle = nil
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encodeIfPresent(screenshot, forKey: .screenshot)
+        try userFeedbackMetadata?.encode(to: encoder)
+    }
+}
+
+/// :nodoc:
+@_spi(MapboxInternal)
+extension UserFeedbackMetadata: Encodable {
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: FeedbackMetadata.CodingKeys.self)
+        let eventLocationsAfter: [EventFixLocation] = locationsAfter.map { .init($0) }
+        let eventLocationsBefore: [EventFixLocation] = locationsBefore.map { .init($0) }
+        let eventStep = step.map { EventStep($0) }
+        try container.encode(eventLocationsAfter, forKey: .locationsAfter)
+        try container.encode(eventLocationsBefore, forKey: .locationsBefore)
+        try container.encodeIfPresent(eventStep, forKey: .step)
+    }
+
+    convenience init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: FeedbackMetadata.CodingKeys.self)
+        let locationsBefore = try container.decode([EventFixLocation].self, forKey: .locationsBefore)
+        let locationsAfter = try container.decode([EventFixLocation].self, forKey: .locationsAfter)
+        let eventStep = try container.decodeIfPresent(EventStep.self, forKey: .step)
+
+        self.init(locationsBefore: locationsBefore.map { FixLocation($0) },
+                  locationsAfter: locationsAfter.map { FixLocation($0) },
+                  step: Step(eventStep))
+    }
+}

Sources/MapboxCoreNavigation/Feedback/FeedbackEvent.swift

@@ -134,10 +134,12 @@ class NativeHandlersFactory {
     }
 
     static func configHandle(by configFactoryType: ConfigFactory.Type = ConfigFactory.self) -> ConfigHandle {
+        var features = ["useInternalReroute": true]
+        if NavigationTelemetryConfiguration.useNavNativeTelemetryEvents {
+            features["useTelemetryNavigationEvents"] = true
+        }
         let defaultConfig = [
-            customConfigFeaturesKey: [
-                "useInternalReroute": true
-            ]
+            customConfigFeaturesKey: features
         ]
 
         var customConfig = UserDefaults.standard.dictionary(forKey: customConfigKey) ?? [:]