1 files changed, 221 insertions, 216 deletions
diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/Transform.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/Transform.java
index 2babc59f1b..88acc13356 100644
--- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/Transform.java
+++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/Transform.java
@@ -21,275 +21,280 @@ import static com.mapbox.mapboxsdk.maps.MapView.REGION_DID_CHANGE_ANIMATED;
 /**
  * Resembles the current Map transformation.
  * <p>
- * Responsible for synchronising {@link CameraPosition} state and notifying {@link com.mapbox.mapboxsdk.maps.MapboxMap.OnCameraChangeListener}.
+ * Responsible for synchronising {@link CameraPosition} state and notifying
+ * {@link com.mapbox.mapboxsdk.maps.MapboxMap.OnCameraChangeListener}.
  * </p>
  */
 final class Transform implements MapView.OnMapChangedListener {
 
-    private final NativeMapView mapView;
-    private final MarkerViewManager markerViewManager;
-    private final TrackingSettings trackingSettings;
-    private final MyLocationView myLocationView;
-
-    private CameraPosition cameraPosition;
-    private MapboxMap.CancelableCallback cameraCancelableCallback;
-    private MapboxMap.OnCameraChangeListener onCameraChangeListener;
-
-    Transform(NativeMapView mapView, MarkerViewManager markerViewManager, TrackingSettings trackingSettings) {
-        this.mapView = mapView;
-        this.markerViewManager = markerViewManager;
-        this.trackingSettings = trackingSettings;
-        this.myLocationView = trackingSettings.getMyLocationView();
+  private final NativeMapView mapView;
+  private final MarkerViewManager markerViewManager;
+  private final TrackingSettings trackingSettings;
+  private final MyLocationView myLocationView;
+
+  private CameraPosition cameraPosition;
+  private MapboxMap.CancelableCallback cameraCancelableCallback;
+  private MapboxMap.OnCameraChangeListener onCameraChangeListener;
+
+  Transform(NativeMapView mapView, MarkerViewManager markerViewManager, TrackingSettings trackingSettings) {
+    this.mapView = mapView;
+    this.markerViewManager = markerViewManager;
+    this.trackingSettings = trackingSettings;
+    this.myLocationView = trackingSettings.getMyLocationView();
+  }
+
+  void initialise(@NonNull MapboxMap mapboxMap, @NonNull MapboxMapOptions options) {
+    CameraPosition position = options.getCamera();
+    if (position != null && !position.equals(CameraPosition.DEFAULT)) {
+      moveCamera(mapboxMap, CameraUpdateFactory.newCameraPosition(position), null);
+    }
+  }
+
+  //
+  // Camera API
+  //
+
+  @UiThread
+  public final CameraPosition getCameraPosition() {
+    if (cameraPosition == null) {
+      cameraPosition = invalidateCameraPosition();
+    }
+    return cameraPosition;
+  }
+
+  @UiThread
+  void updateCameraPosition(@NonNull CameraPosition position) {
+    if (myLocationView != null) {
+      myLocationView.setCameraPosition(position);
+    }
+    markerViewManager.setTilt((float) position.tilt);
+  }
+
+  @Override
+  public void onMapChanged(@MapView.MapChange int change) {
+    if (change == REGION_DID_CHANGE_ANIMATED && cameraCancelableCallback != null) {
+      invalidateCameraPosition();
+      if (cameraCancelableCallback != null) {
+        cameraCancelableCallback.onFinish();
+        cameraCancelableCallback = null;
+      }
+      mapView.removeOnMapChangedListener(this);
+    }
+  }
+
+  @UiThread
+  final void moveCamera(MapboxMap mapboxMap, CameraUpdate update, MapboxMap.CancelableCallback callback) {
+    cameraPosition = update.getCameraPosition(mapboxMap);
+    trackingSettings.resetTrackingModesIfRequired(cameraPosition);
+    cancelTransitions();
+    mapView.jumpTo(cameraPosition.bearing, cameraPosition.target, cameraPosition.tilt, cameraPosition.zoom);
+    if (callback != null) {
+      callback.onFinish();
+    }
+  }
+
+  @UiThread
+  final void easeCamera(MapboxMap mapboxMap, CameraUpdate update, int durationMs, boolean easingInterpolator,
+                        boolean resetTrackingMode, final MapboxMap.CancelableCallback callback) {
+    cameraPosition = update.getCameraPosition(mapboxMap);
+    if (resetTrackingMode) {
+      trackingSettings.resetTrackingModesIfRequired(cameraPosition);
     }
 
-    void initialise(@NonNull MapboxMap mapboxMap, @NonNull MapboxMapOptions options) {
-        CameraPosition position = options.getCamera();
-        if (position != null && !position.equals(CameraPosition.DEFAULT)) {
-            moveCamera(mapboxMap, CameraUpdateFactory.newCameraPosition(position), null);
-        }
-    }
+    cancelTransitions();
+    if (callback != null) {
+      cameraCancelableCallback = callback;
+      mapView.addOnMapChangedListener(this);
+    }
+
+    mapView.easeTo(cameraPosition.bearing, cameraPosition.target, getDurationNano(durationMs), cameraPosition.tilt,
+      cameraPosition.zoom, easingInterpolator);
+  }
 
-    //
-    // Camera API
-    //
+  @UiThread
+  final void animateCamera(MapboxMap mapboxMap, CameraUpdate update, int durationMs,
+                           final MapboxMap.CancelableCallback callback) {
+    cameraPosition = update.getCameraPosition(mapboxMap);
+    trackingSettings.resetTrackingModesIfRequired(cameraPosition);
 
-    @UiThread
-    public final CameraPosition getCameraPosition() {
-        if (cameraPosition == null) {
-            cameraPosition = invalidateCameraPosition();
-        }
-        return cameraPosition;
+    cancelTransitions();
+    if (callback != null) {
+      cameraCancelableCallback = callback;
+      mapView.addOnMapChangedListener(this);
     }
 
-    @UiThread
-    void updateCameraPosition(@NonNull CameraPosition position) {
-        if (myLocationView != null) {
-            myLocationView.setCameraPosition(position);
-        }
-        markerViewManager.setTilt((float) position.tilt);
-    }
+    mapView.flyTo(cameraPosition.bearing, cameraPosition.target, getDurationNano(durationMs), cameraPosition.tilt,
+      cameraPosition.zoom);
+  }
 
-    @Override
-    public void onMapChanged(@MapView.MapChange int change) {
-        if (change == REGION_DID_CHANGE_ANIMATED && cameraCancelableCallback != null) {
-            invalidateCameraPosition();
-            if (cameraCancelableCallback != null) {
-                cameraCancelableCallback.onFinish();
-                cameraCancelableCallback = null;
-            }
-            mapView.removeOnMapChangedListener(this);
-        }
+  @UiThread
+  @Nullable
+  CameraPosition invalidateCameraPosition() {
+    if (mapView != null) {
+      cameraPosition = new CameraPosition.Builder(mapView.getCameraValues()).build();
+      if (onCameraChangeListener != null) {
+        onCameraChangeListener.onCameraChange(this.cameraPosition);
+      }
     }
+    return cameraPosition;
+  }
 
-    @UiThread
-    final void moveCamera(MapboxMap mapboxMap, CameraUpdate update, MapboxMap.CancelableCallback callback) {
-        cameraPosition = update.getCameraPosition(mapboxMap);
-        trackingSettings.resetTrackingModesIfRequired(cameraPosition);
-        cancelTransitions();
-        mapView.jumpTo(cameraPosition.bearing, cameraPosition.target, cameraPosition.tilt, cameraPosition.zoom);
-        if (callback != null) {
-            callback.onFinish();
-        }
+  void cancelTransitions() {
+    if (cameraCancelableCallback != null) {
+      cameraCancelableCallback.onCancel();
+      cameraCancelableCallback = null;
     }
+    mapView.cancelTransitions();
+  }
 
-    @UiThread
-    final void easeCamera(MapboxMap mapboxMap, CameraUpdate update, int durationMs, boolean easingInterpolator, boolean resetTrackingMode, final MapboxMap.CancelableCallback callback) {
-        cameraPosition = update.getCameraPosition(mapboxMap);
-        if (resetTrackingMode) {
-            trackingSettings.resetTrackingModesIfRequired(cameraPosition);
-        }
+  @UiThread
+  void resetNorth() {
+    cancelTransitions();
+    mapView.resetNorth();
+  }
 
-        cancelTransitions();
-        if (callback != null) {
-            cameraCancelableCallback = callback;
-            mapView.addOnMapChangedListener(this);
-        }
+  void setOnCameraChangeListener(@Nullable MapboxMap.OnCameraChangeListener listener) {
+    this.onCameraChangeListener = listener;
+  }
 
-        mapView.easeTo(cameraPosition.bearing, cameraPosition.target, getDurationNano(durationMs), cameraPosition.tilt, cameraPosition.zoom, easingInterpolator);
-    }
+  private long getDurationNano(long durationMs) {
+    return durationMs > 0 ? TimeUnit.NANOSECONDS.convert(durationMs, TimeUnit.MILLISECONDS) : 0;
+  }
 
-    @UiThread
-    final void animateCamera(MapboxMap mapboxMap, CameraUpdate update, int durationMs, final MapboxMap.CancelableCallback callback) {
-        cameraPosition = update.getCameraPosition(mapboxMap);
-        trackingSettings.resetTrackingModesIfRequired(cameraPosition);
+  //
+  // non Camera API
+  //
 
-        cancelTransitions();
-        if (callback != null) {
-            cameraCancelableCallback = callback;
-            mapView.addOnMapChangedListener(this);
-        }
+  // Zoom in or out
 
-        mapView.flyTo(cameraPosition.bearing, cameraPosition.target, getDurationNano(durationMs), cameraPosition.tilt, cameraPosition.zoom);
-    }
+  double getZoom() {
+    return cameraPosition.zoom;
+  }
 
-    @UiThread
-    @Nullable
-    CameraPosition invalidateCameraPosition() {
-        if (mapView != null) {
-            cameraPosition = new CameraPosition.Builder(mapView.getCameraValues()).build();
-            if (onCameraChangeListener != null) {
-                onCameraChangeListener.onCameraChange(this.cameraPosition);
-            }
-        }
-        return cameraPosition;
-    }
+  void zoom(boolean zoomIn) {
+    zoom(zoomIn, -1.0f, -1.0f);
+  }
 
-    void cancelTransitions() {
-        if (cameraCancelableCallback != null) {
-            cameraCancelableCallback.onCancel();
-            cameraCancelableCallback = null;
-        }
-        mapView.cancelTransitions();
-    }
+  void zoom(boolean zoomIn, float x, float y) {
+    // Cancel any animation
+    cancelTransitions();
 
-    @UiThread
-    void resetNorth() {
-        cancelTransitions();
-        mapView.resetNorth();
+    if (zoomIn) {
+      mapView.scaleBy(2.0, x, y, MapboxConstants.ANIMATION_DURATION);
+    } else {
+      mapView.scaleBy(0.5, x, y, MapboxConstants.ANIMATION_DURATION);
     }
+  }
 
-    void setOnCameraChangeListener(@Nullable MapboxMap.OnCameraChangeListener listener) {
-        this.onCameraChangeListener = listener;
-    }
+  // Direction
+  double getBearing() {
+    double direction = -mapView.getBearing();
 
-    private long getDurationNano(long durationMs) {
-        return durationMs > 0 ? TimeUnit.NANOSECONDS.convert(durationMs, TimeUnit.MILLISECONDS) : 0;
+    while (direction > 360) {
+      direction -= 360;
     }
-
-    //
-    // non Camera API
-    //
-
-    // Zoom in or out
-
-    double getZoom() {
-        return cameraPosition.zoom;
+    while (direction < 0) {
+      direction += 360;
     }
 
-    void zoom(boolean zoomIn) {
-        zoom(zoomIn, -1.0f, -1.0f);
-    }
+    return direction;
+  }
 
-    void zoom(boolean zoomIn, float x, float y) {
-        // Cancel any animation
-        cancelTransitions();
+  double getRawBearing() {
+    return mapView.getBearing();
+  }
 
-        if (zoomIn) {
-            mapView.scaleBy(2.0, x, y, MapboxConstants.ANIMATION_DURATION);
-        } else {
-            mapView.scaleBy(0.5, x, y, MapboxConstants.ANIMATION_DURATION);
-        }
+  void setBearing(double bearing) {
+    if (myLocationView != null) {
+      myLocationView.setBearing(bearing);
     }
+    mapView.setBearing(bearing);
+  }
 
-    // Direction
-    double getBearing() {
-        double direction = -mapView.getBearing();
-
-        while (direction > 360) {
-            direction -= 360;
-        }
-        while (direction < 0) {
-            direction += 360;
-        }
-
-        return direction;
+  void setBearing(double bearing, float focalX, float focalY) {
+    if (myLocationView != null) {
+      myLocationView.setBearing(bearing);
     }
+    mapView.setBearing(bearing, focalX, focalY);
+  }
 
-    double getRawBearing(){
-        return mapView.getBearing();
-    }
-
-    void setBearing(double bearing) {
-        if (myLocationView != null) {
-            myLocationView.setBearing(bearing);
-        }
-        mapView.setBearing(bearing);
-    }
 
-    void setBearing(double bearing, float focalX, float focalY) {
-        if (myLocationView != null) {
-            myLocationView.setBearing(bearing);
-        }
-        mapView.setBearing(bearing, focalX, focalY);
-    }
+  //
+  // LatLng / CenterCoordinate
+  //
 
+  LatLng getLatLng() {
+    return mapView.getLatLng();
+  }
 
-    //
-    // LatLng / CenterCoordinate
-    //
-
-    LatLng getLatLng() {
-        return mapView.getLatLng();
-    }
-
-    //
-    // Pitch / Tilt
-    //
+  //
+  // Pitch / Tilt
+  //
 
-    double getTilt() {
-        return mapView.getPitch();
-    }
+  double getTilt() {
+    return mapView.getPitch();
+  }
 
-    void setTilt(Double pitch) {
-        if (myLocationView != null) {
-            myLocationView.setTilt(pitch);
-        }
-        markerViewManager.setTilt(pitch.floatValue());
-        mapView.setPitch(pitch, 0);
+  void setTilt(Double pitch) {
+    if (myLocationView != null) {
+      myLocationView.setTilt(pitch);
     }
+    markerViewManager.setTilt(pitch.floatValue());
+    mapView.setPitch(pitch, 0);
+  }
 
-    //
-    // Center coordinate
-    //
+  //
+  // Center coordinate
+  //
 
-    LatLng getCenterCoordinate() {
-        return mapView.getLatLng();
-    }
+  LatLng getCenterCoordinate() {
+    return mapView.getLatLng();
+  }
 
-    void setCenterCoordinate(LatLng centerCoordinate) {
-        mapView.setLatLng(centerCoordinate);
-    }
+  void setCenterCoordinate(LatLng centerCoordinate) {
+    mapView.setLatLng(centerCoordinate);
+  }
 
-    void setGestureInProgress(boolean gestureInProgress) {
-        mapView.setGestureInProgress(gestureInProgress);
-        if (!gestureInProgress) {
-            invalidateCameraPosition();
-        }
+  void setGestureInProgress(boolean gestureInProgress) {
+    mapView.setGestureInProgress(gestureInProgress);
+    if (!gestureInProgress) {
+      invalidateCameraPosition();
     }
+  }
 
-    void zoomBy(double pow, float x, float y) {
-        mapView.scaleBy(pow, x, y);
-    }
+  void zoomBy(double pow, float x, float y) {
+    mapView.scaleBy(pow, x, y);
+  }
 
-    void moveBy(double offsetX, double offsetY, long duration) {
-        mapView.moveBy(offsetX, offsetY, duration);
-    }
+  void moveBy(double offsetX, double offsetY, long duration) {
+    mapView.moveBy(offsetX, offsetY, duration);
+  }
 
-    //
-    // Min & Max ZoomLevel
-    //
+  //
+  // Min & Max ZoomLevel
+  //
 
-    void setMinZoom(double minZoom) {
-        if ((minZoom < MapboxConstants.MINIMUM_ZOOM) || (minZoom > MapboxConstants.MAXIMUM_ZOOM)) {
-            Timber.e("Not setting minZoomPreference, value is in unsupported range: " + minZoom);
-            return;
-        }
-        mapView.setMinZoom(minZoom);
+  void setMinZoom(double minZoom) {
+    if ((minZoom < MapboxConstants.MINIMUM_ZOOM) || (minZoom > MapboxConstants.MAXIMUM_ZOOM)) {
+      Timber.e("Not setting minZoomPreference, value is in unsupported range: " + minZoom);
+      return;
     }
+    mapView.setMinZoom(minZoom);
+  }
 
-    double getMinZoom() {
-        return mapView.getMinZoom();
-    }
+  double getMinZoom() {
+    return mapView.getMinZoom();
+  }
 
-    void setMaxZoom(double maxZoom) {
-        if ((maxZoom < MapboxConstants.MINIMUM_ZOOM) || (maxZoom > MapboxConstants.MAXIMUM_ZOOM)) {
-            Timber.e("Not setting maxZoomPreference, value is in unsupported range: " + maxZoom);
-            return;
-        }
-        mapView.setMaxZoom(maxZoom);
+  void setMaxZoom(double maxZoom) {
+    if ((maxZoom < MapboxConstants.MINIMUM_ZOOM) || (maxZoom > MapboxConstants.MAXIMUM_ZOOM)) {
+      Timber.e("Not setting maxZoomPreference, value is in unsupported range: " + maxZoom);
+      return;
     }
+    mapView.setMaxZoom(maxZoom);
+  }
 
-    double getMaxZoom() {
-        return mapView.getMaxZoom();
-    }
+  double getMaxZoom() {
+    return mapView.getMaxZoom();
+  }
 }