reroute metric (#296)

* initial reroute metric added

* more metadata added

* removed safeguards used for preventing null objects

* updated MAS with new metric fixes

* remove staging info in manifest

Author: Cameron Mace

app/src/main/AndroidManifest.xml

@@ -49,6 +49,5 @@
                 android:name="android.support.PARENT_ACTIVITY"
                 android:value=".MainActivity"/>
         </activity>
-
     </application>
 </manifest>

gradle/dependencies.gradle

@@ -9,7 +9,7 @@ ext {
 
   version = [
       mapboxMapSdk       : '5.1.4',
-      mapboxServices     : '2.2.5',
+      mapboxServices     : '2.2.6',
       locationLayerPlugin: '0.1.0',
       autoValue          : '1.4.1',
       autoValueParcel    : '0.2.5',

libandroid-navigation/src/main/java/com/mapbox/services/android/navigation/v5/navigation/MapboxNavigation.java

@@ -48,8 +48,10 @@
  * @since 0.1.0
  */
 public class MapboxNavigation implements ServiceConnection, ProgressChangeListener {
+
   private static final String MAPBOX_NAVIGATION_SDK_IDENTIFIER = "mapbox-navigation-android";
   private static final String MAPBOX_NAVIGATION_UI_SDK_IDENTIFIER = "mapbox-navigation-ui-android";
+
   private NavigationEventDispatcher navigationEventDispatcher;
   private NavigationService navigationService;
   private DirectionsRoute directionsRoute;
@@ -373,6 +375,8 @@ public void startNavigation(@NonNull DirectionsRoute directionsRoute) {
         .currentDirectionRoute(directionsRoute)
         .rerouteCount(sessionState.rerouteCount() + 1)
         .build();
+
+      navigationService.rerouteOccurred();
     }
   }
 
@@ -651,6 +655,10 @@ SessionState getSessionState() {
     return sessionState;
   }
 
+  void setSessionState(SessionState sessionState) {
+    this.sessionState = sessionState;
+  }
+
   private Intent getServiceIntent() {
     return new Intent(context, NavigationService.class);
   }

libandroid-navigation/src/main/java/com/mapbox/services/android/navigation/v5/navigation/NavigationMetricsWrapper.java

@@ -64,6 +64,68 @@ static void departEvent(SessionState sessionState, RouteProgress routeProgress,
     ));
   }
 
+  static void rerouteEvent(SessionState sessionState, RouteProgress routeProgress, Location location) {
+    String upcomingInstruction = null;
+    String previousInstruction = null;
+    String upcomingModifier = null;
+    String previousModifier = null;
+    String upcomingType = null;
+    String upcomingName = null;
+    String previousType = null;
+
+    if (routeProgress.currentLegProgress().upComingStep() != null) {
+      upcomingName = routeProgress.currentLegProgress().upComingStep().getName();
+      if (routeProgress.currentLegProgress().upComingStep().getManeuver() != null) {
+        upcomingInstruction = routeProgress.currentLegProgress().upComingStep().getManeuver().getInstruction();
+        upcomingType = routeProgress.currentLegProgress().upComingStep().getManeuver().getType();
+        upcomingModifier = routeProgress.currentLegProgress().upComingStep().getManeuver().getModifier();
+      }
+    }
+
+    if (routeProgress.currentLegProgress().currentStep().getManeuver() != null) {
+      previousInstruction = routeProgress.currentLegProgress().currentStep().getManeuver().getInstruction();
+      previousType = routeProgress.currentLegProgress().currentStep().getManeuver().getType();
+      previousModifier = routeProgress.currentLegProgress().currentStep().getManeuver().getModifier();
+    }
+
+    Location[] beforeLocations = null;
+    if (sessionState.beforeRerouteLocations() != null && !sessionState.beforeRerouteLocations().isEmpty()) {
+      beforeLocations = (Location[]) sessionState.beforeRerouteLocations().toArray();
+    }
+
+    Location[] afterLocations = null;
+    if (sessionState.afterRerouteLocations() != null && !sessionState.afterRerouteLocations().isEmpty()) {
+      afterLocations = (Location[]) sessionState.afterRerouteLocations().toArray();
+    }
+
+    String previousName = routeProgress.currentLegProgress().currentStep().getName();
+
+    MapboxTelemetry.getInstance().pushEvent(MapboxNavigationEvent.buildRerouteEvent(
+      sdkIdentifier, BuildConfig.MAPBOX_NAVIGATION_VERSION_NAME, sessionState.sessionIdentifier(),
+      location.getLatitude(), location.getLongitude(),
+      sessionState.currentGeometry(), "unknown",
+      (int) routeProgress.directionsRoute().getDistance(),
+      (int) routeProgress.directionsRoute().getDuration(),
+      sessionState.rerouteCount(), sessionState.startTimestamp(), beforeLocations, afterLocations,
+      (int) sessionState.routeProgressBeforeReroute().distanceTraveled(),
+      (int) sessionState.routeProgressBeforeReroute().distanceRemaining(),
+      (int) sessionState.routeProgressBeforeReroute().durationRemaining(),
+      (int) routeProgress.distanceRemaining(),
+      (int) routeProgress.durationRemaining(),
+      sessionState.secondsSinceLastReroute(), "",
+      routeProgress.directionsRoute().getGeometry(), sessionState.mockLocation(),
+      null, null, sessionState.originalGeometry(),
+      sessionState.originalDistance(), sessionState.originalDuration(), null,
+      upcomingInstruction, upcomingType, upcomingModifier, upcomingName, previousInstruction,
+      previousType, previousModifier,
+      previousName, (int) routeProgress.currentLegProgress().currentStep().getDistance(),
+      (int) routeProgress.currentLegProgress().currentStep().getDuration(),
+      (int) routeProgress.currentLegProgress().currentStepProgress().distanceRemaining(),
+      (int) routeProgress.currentLegProgress().currentStepProgress().durationRemaining(),
+      sessionState.currentStepCount(), sessionState.originalStepCount()
+    ));
+  }
+
   static void turnstileEvent() {
     MapboxTelemetry.getInstance().setCustomTurnstileEvent(
       MapboxNavigationEvent.buildTurnstileEvent(sdkIdentifier, BuildConfig.MAPBOX_NAVIGATION_VERSION_NAME)

libandroid-navigation/src/main/java/com/mapbox/services/android/navigation/v5/navigation/NavigationService.java

@@ -19,6 +19,7 @@
 import com.mapbox.services.android.telemetry.location.LocationEngineListener;
 import com.mapbox.services.api.directions.v5.models.DirectionsRoute;
 
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
@@ -43,17 +44,22 @@ public class NavigationService extends Service implements LocationEngineListener
 
   // Message id used when a new location update occurs and we send to the thread.
   private static final int MSG_LOCATION_UPDATED = 1001;
+  private static final int TWENTY_SECOND_INTERVAL = 20000;
 
   private RingBuffer<Integer> recentDistancesFromManeuverInMeters;
   private final IBinder localBinder = new LocalBinder();
   private NavigationNotification navNotificationManager;
+  private RingBuffer<Location> locationBuffer;
   private long timeIntervalSinceLastOffRoute;
   private MapboxNavigation mapboxNavigation;
   private LocationEngine locationEngine;
   private RouteProgress routeProgress;
   private boolean firstProgressUpdate = true;
+  private boolean queuedRerouteEvent;
   private NavigationEngine thread;
   private Location location;
+  private Runnable runnable;
+  private Handler handler;
 
   @Nullable
   @Override
@@ -67,6 +73,7 @@ public void onCreate() {
     thread.start();
     thread.prepareHandler();
     recentDistancesFromManeuverInMeters = new RingBuffer<>(3);
+    locationBuffer = new RingBuffer<>(20);
   }
 
   /**
@@ -80,16 +87,25 @@ public int onStartCommand(Intent intent, int flags, int startId) {
 
   @Override
   public void onDestroy() {
-    super.onDestroy();
     if (mapboxNavigation.options().enableNotification()) {
       stopForeground(true);
     }
+
+    if (handler != null && runnable != null) {
+      if (queuedRerouteEvent) {
+        runnable.run();
+      }
+      handler.removeCallbacks(runnable);
+
+    }
+
     // User canceled navigation session
     if (routeProgress != null && location != null) {
       NavigationMetricsWrapper.cancelEvent(mapboxNavigation.getSessionState(), routeProgress,
         location);
     }
     endNavigation();
+    super.onDestroy();
   }
 
   /**
@@ -166,11 +182,10 @@ public void onConnected() {
   @Override
   public void onLocationChanged(Location location) {
     Timber.d("onLocationChanged");
-    if (location != null) {
-      if (validLocationUpdate(location)) {
-        thread.queueTask(MSG_LOCATION_UPDATED, NewLocationModel.create(location, mapboxNavigation,
-          recentDistancesFromManeuverInMeters));
-      }
+    if (location != null && validLocationUpdate(location)) {
+      locationBuffer.push(location);
+      thread.queueTask(MSG_LOCATION_UPDATED, NewLocationModel.create(location, mapboxNavigation,
+        recentDistancesFromManeuverInMeters));
     }
   }
 
@@ -244,6 +259,34 @@ public void onUserOffRoute(Location location, boolean userOffRoute) {
     }
   }
 
+  public void rerouteOccurred() {
+    mapboxNavigation.setSessionState(mapboxNavigation.getSessionState().toBuilder()
+      .beforeRerouteLocations(Arrays.asList(
+        locationBuffer.toArray(new Location[locationBuffer.size()])))
+      .routeProgressBeforeReroute(routeProgress)
+      .build());
+    locationBuffer.clear();
+    queuedRerouteEvent = true;
+
+    handler = new Handler();
+    runnable = new Runnable() {
+      @Override
+      public void run() {
+        mapboxNavigation.setSessionState(mapboxNavigation.getSessionState().toBuilder()
+          .afterRerouteLocations(Arrays.asList(
+            locationBuffer.toArray(new Location[locationBuffer.size()])))
+          .build());
+
+        locationBuffer.clear();
+
+        NavigationMetricsWrapper.rerouteEvent(mapboxNavigation.getSessionState(), routeProgress,
+          location);
+        queuedRerouteEvent = false;
+      }
+    };
+    handler.postDelayed(runnable, TWENTY_SECOND_INTERVAL);
+  }
+
   class LocalBinder extends Binder {
     NavigationService getService() {
       Timber.d("Local binder called.");

libandroid-navigation/src/main/java/com/mapbox/services/android/navigation/v5/navigation/SessionState.java

@@ -1,17 +1,20 @@
 package com.mapbox.services.android.navigation.v5.navigation;
 
+import android.location.Location;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 
 import com.google.auto.value.AutoValue;
 import com.mapbox.services.Constants;
+import com.mapbox.services.android.navigation.v5.routeprogress.RouteProgress;
 import com.mapbox.services.api.directions.v5.models.DirectionsRoute;
 import com.mapbox.services.api.directions.v5.models.RouteLeg;
 import com.mapbox.services.commons.models.Position;
 import com.mapbox.services.commons.utils.PolylineUtils;
 
 import java.util.Date;
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 
 @AutoValue
 abstract class SessionState {
@@ -64,6 +67,17 @@ int currentStepCount() {
 
   abstract DirectionsRoute currentDirectionRoute();
 
+  int secondsSinceLastReroute() {
+    if (lastRerouteDate() == null) {
+      return -1;
+    }
+    long diffInMs = lastRerouteDate().getTime() - new Date().getTime();
+    return (int) TimeUnit.MILLISECONDS.toSeconds(diffInMs);
+  }
+
+  @Nullable
+  abstract Date lastRerouteDate();
+
   abstract Date startTimestamp();
 
   @Nullable
@@ -75,16 +89,30 @@ int currentStepCount() {
 
   abstract double previousRouteDistancesCompleted();
 
+  @Nullable
+  abstract List<Location> beforeRerouteLocations();
+
+  @Nullable
+  abstract List<Location> afterRerouteLocations();
+
+  @Nullable
+  abstract RouteProgress routeProgressBeforeReroute();
+
   abstract Builder toBuilder();
 
   static Builder builder() {
     return new AutoValue_SessionState.Builder();
   }
 
-
   @AutoValue.Builder
   abstract static class Builder {
 
+    abstract Builder routeProgressBeforeReroute(@Nullable RouteProgress routeProgress);
+
+    abstract Builder afterRerouteLocations(@Nullable List<Location> beforeLocations);
+
+    abstract Builder beforeRerouteLocations(@Nullable List<Location> beforeLocations);
+
     abstract Builder originalDirectionRoute(@NonNull DirectionsRoute directionsRoute);
 
     abstract Builder currentDirectionRoute(@NonNull DirectionsRoute directionsRoute);
@@ -95,6 +123,8 @@ abstract static class Builder {
 
     abstract Builder requestIdentifier(@Nullable String requestIdentifier);
 
+    abstract Builder lastRerouteDate(@Nullable Date lastRerouteDate);
+
     abstract Builder mockLocation(boolean mockLocation);
 
     abstract Builder rerouteCount(int rerouteCount);