Adds checkstyle to CI (#7442)

* adds checkstyle to CI

* fixed gradlew path

* resolved testapp checkstyle violations

* added back mapboxMap variable for test

* checkstyle annotations

* checkstyle SDK round 1

* maps package checkstyle

* rest of SDK checkstyle

* checkstyle gesture library

* checkstyle test

* finished rest of test checkstyle

* resolved all checkstyle errors

* fixed class name

* removed old test file

* fixed camera postion test

* fixed native crash

1 files changed, 555 insertions, 552 deletions

diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/AnnotationManager.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/AnnotationManager.java
index eb90ae764b..bffcf2fa2f 100644
--- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/AnnotationManager.java
+++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/AnnotationManager.java
@@ -30,656 +30,659 @@ import java.util.List;
  * Responsible for referencing {@link InfoWindowManager} and {@link MarkerViewManager}.
  * </p>
  * <p>
- * Exposes convenience methods to add/remove/update all subtypes of annotations found in com.mapbox.mapboxsdk.annotations.
+ * Exposes convenience methods to add/remove/update all subtypes of annotations found in
+ * com.mapbox.mapboxsdk.annotations.
  * </p>
  */
 class AnnotationManager {
 
-    private final NativeMapView nativeMapView;
-    private final MapView mapView;
-    private final IconManager iconManager;
-    private final InfoWindowManager infoWindowManager = new InfoWindowManager();
-    private final MarkerViewManager markerViewManager;
-    private final LongSparseArray<Annotation> annotations = new LongSparseArray<>();
-    private final List<Marker> selectedMarkers = new ArrayList<>();
-
-    private MapboxMap mapboxMap;
-
-    private HashMap<MarkerView, MarkerViewManager.OnMarkerViewAddedListener> markerMap = new HashMap<>();
-    private MapboxMap.OnMarkerClickListener onMarkerClickListener;
-
-    AnnotationManager(NativeMapView view, MapView mapView, MarkerViewManager markerViewManager) {
-        this.nativeMapView = view;
-        this.mapView = mapView;
-        this.iconManager = new IconManager(nativeMapView);
-        this.markerViewManager = markerViewManager;
-        if (view != null) {
-            // null checking needed for unit tests
-            nativeMapView.addOnMapChangedListener(markerViewManager);
+  private final NativeMapView nativeMapView;
+  private final MapView mapView;
+  private final IconManager iconManager;
+  private final InfoWindowManager infoWindowManager = new InfoWindowManager();
+  private final MarkerViewManager markerViewManager;
+  private final LongSparseArray<Annotation> annotations = new LongSparseArray<>();
+  private final List<Marker> selectedMarkers = new ArrayList<>();
+
+  private MapboxMap mapboxMap;
+
+  private HashMap<MarkerView, MarkerViewManager.OnMarkerViewAddedListener> markerMap = new HashMap<>();
+  private MapboxMap.OnMarkerClickListener onMarkerClickListener;
+
+  AnnotationManager(NativeMapView view, MapView mapView, MarkerViewManager markerViewManager) {
+    this.nativeMapView = view;
+    this.mapView = mapView;
+    this.iconManager = new IconManager(nativeMapView);
+    this.markerViewManager = markerViewManager;
+    if (view != null) {
+      // null checking needed for unit tests
+      nativeMapView.addOnMapChangedListener(markerViewManager);
+    }
+  }
+
+  // TODO refactor MapboxMap out for Projection and Transform
+  // Requires removing MapboxMap from Annotations by using Peer model from #6912
+  AnnotationManager bind(MapboxMap mapboxMap) {
+    this.mapboxMap = mapboxMap;
+    this.markerViewManager.bind(mapboxMap);
+    return this;
+  }
+
+  //
+  // Annotations
+  //
+
+  Annotation getAnnotation(long id) {
+    return annotations.get(id);
+  }
+
+  List<Annotation> getAnnotations() {
+    List<Annotation> annotations = new ArrayList<>();
+    for (int i = 0; i < this.annotations.size(); i++) {
+      annotations.add(this.annotations.get(this.annotations.keyAt(i)));
+    }
+    return annotations;
+  }
+
+  void removeAnnotation(@NonNull Annotation annotation) {
+    if (annotation instanceof Marker) {
+      Marker marker = (Marker) annotation;
+      marker.hideInfoWindow();
+      if (marker instanceof MarkerView) {
+        markerViewManager.removeMarkerView((MarkerView) marker);
+      }
+    }
+    long id = annotation.getId();
+    if (nativeMapView != null) {
+      nativeMapView.removeAnnotation(id);
+    }
+    annotations.remove(id);
+  }
+
+  void removeAnnotation(long id) {
+    if (nativeMapView != null) {
+      nativeMapView.removeAnnotation(id);
+    }
+    annotations.remove(id);
+  }
+
+  void removeAnnotations(@NonNull List<? extends Annotation> annotationList) {
+    int count = annotationList.size();
+    long[] ids = new long[count];
+    for (int i = 0; i < count; i++) {
+      Annotation annotation = annotationList.get(i);
+      if (annotation instanceof Marker) {
+        Marker marker = (Marker) annotation;
+        marker.hideInfoWindow();
+        if (marker instanceof MarkerView) {
+          markerViewManager.removeMarkerView((MarkerView) marker);
         }
+      }
+      ids[i] = annotationList.get(i).getId();
     }
 
-    // TODO refactor MapboxMap out for Projection and Transform
-    // Requires removing MapboxMap from Annotations by using Peer model from #6912
-    AnnotationManager bind(MapboxMap mapboxMap) {
-        this.mapboxMap = mapboxMap;
-        this.markerViewManager.bind(mapboxMap);
-        return this;
+    if (nativeMapView != null) {
+      nativeMapView.removeAnnotations(ids);
     }
 
-    //
-    // Annotations
-    //
-
-    Annotation getAnnotation(long id) {
-        return annotations.get(id);
+    for (long id : ids) {
+      annotations.remove(id);
     }
+  }
 
-    List<Annotation> getAnnotations() {
-        List<Annotation> annotations = new ArrayList<>();
-        for (int i = 0; i < this.annotations.size(); i++) {
-            annotations.add(this.annotations.get(this.annotations.keyAt(i)));
+  void removeAnnotations() {
+    Annotation annotation;
+    int count = annotations.size();
+    long[] ids = new long[count];
+    for (int i = 0; i < count; i++) {
+      ids[i] = annotations.keyAt(i);
+      annotation = annotations.get(ids[i]);
+      if (annotation instanceof Marker) {
+        Marker marker = (Marker) annotation;
+        marker.hideInfoWindow();
+        if (marker instanceof MarkerView) {
+          markerViewManager.removeMarkerView((MarkerView) marker);
         }
-        return annotations;
+      }
     }
 
-    void removeAnnotation(@NonNull Annotation annotation) {
-        if (annotation instanceof Marker) {
-            Marker marker = (Marker) annotation;
-            marker.hideInfoWindow();
-            if (marker instanceof MarkerView) {
-                markerViewManager.removeMarkerView((MarkerView) marker);
-            }
-        }
-        long id = annotation.getId();
-        if (nativeMapView != null) {
-            nativeMapView.removeAnnotation(id);
-        }
-        annotations.remove(id);
+    if (nativeMapView != null) {
+      nativeMapView.removeAnnotations(ids);
     }
 
-    void removeAnnotation(long id) {
-        if (nativeMapView != null) {
-            nativeMapView.removeAnnotation(id);
-        }
-        annotations.remove(id);
-    }
-
-    void removeAnnotations(@NonNull List<? extends Annotation> annotationList) {
-        int count = annotationList.size();
-        long[] ids = new long[count];
-        for (int i = 0; i < count; i++) {
-            Annotation annotation = annotationList.get(i);
-            if (annotation instanceof Marker) {
-                Marker marker = (Marker) annotation;
-                marker.hideInfoWindow();
-                if (marker instanceof MarkerView) {
-                    markerViewManager.removeMarkerView((MarkerView) marker);
-                }
-            }
-            ids[i] = annotationList.get(i).getId();
-        }
-
-        if (nativeMapView != null) {
-            nativeMapView.removeAnnotations(ids);
-        }
+    annotations.clear();
+  }
 
-        for (long id : ids) {
-            annotations.remove(id);
-        }
-    }
+  //
+  // Markers
+  //
 
-    void removeAnnotations() {
-        Annotation annotation;
-        int count = annotations.size();
-        long[] ids = new long[count];
-        for (int i = 0; i < count; i++) {
-            ids[i] = annotations.keyAt(i);
-            annotation = annotations.get(ids[i]);
-            if (annotation instanceof Marker) {
-                Marker marker = (Marker) annotation;
-                marker.hideInfoWindow();
-                if (marker instanceof MarkerView) {
-                    markerViewManager.removeMarkerView((MarkerView) marker);
-                }
-            }
-        }
+  List<Marker> addMarkers(@NonNull List<? extends BaseMarkerOptions> markerOptionsList, @NonNull MapboxMap mapboxMap) {
+    int count = markerOptionsList.size();
+    List<Marker> markers = new ArrayList<>(count);
+    if (count > 0) {
+      BaseMarkerOptions markerOptions;
+      Marker marker;
+      for (int i = 0; i < count; i++) {
+        markerOptions = markerOptionsList.get(i);
+        marker = prepareMarker(markerOptions);
+        markers.add(marker);
+      }
 
+      if (markers.size() > 0) {
+        long[] ids = null;
         if (nativeMapView != null) {
-            nativeMapView.removeAnnotations(ids);
-        }
-
-        annotations.clear();
-    }
-
-    //
-    // Markers
-    //
-
-    Marker addMarker(@NonNull BaseMarkerOptions markerOptions, @NonNull MapboxMap mapboxMap) {
-        Marker marker = prepareMarker(markerOptions);
-        long id = nativeMapView != null ? nativeMapView.addMarker(marker) : 0;
-        marker.setMapboxMap(mapboxMap);
-        marker.setId(id);
-        annotations.put(id, marker);
-        return marker;
+          ids = nativeMapView.addMarkers(markers);
+        }
+
+        long id = 0;
+        Marker m;
+        for (int i = 0; i < markers.size(); i++) {
+          m = markers.get(i);
+          m.setMapboxMap(mapboxMap);
+          if (ids != null) {
+            id = ids[i];
+          } else {
+            //unit test
+            id++;
+          }
+          m.setId(id);
+          annotations.put(id, m);
+        }
+
+      }
+    }
+    return markers;
+  }
+
+  private Marker prepareMarker(BaseMarkerOptions markerOptions) {
+    Marker marker = markerOptions.getMarker();
+    Icon icon = iconManager.loadIconForMarker(marker);
+    marker.setTopOffsetPixels(iconManager.getTopOffsetPixelsForIcon(icon));
+    return marker;
+  }
+
+  Marker addMarker(@NonNull BaseMarkerOptions markerOptions, @NonNull MapboxMap mapboxMap) {
+    Marker marker = prepareMarker(markerOptions);
+    long id = nativeMapView != null ? nativeMapView.addMarker(marker) : 0;
+    marker.setMapboxMap(mapboxMap);
+    marker.setId(id);
+    annotations.put(id, marker);
+    return marker;
+  }
+
+  MarkerView addMarker(@NonNull BaseMarkerViewOptions markerOptions, @NonNull MapboxMap mapboxMap) {
+    MarkerView marker = prepareViewMarker(markerOptions);
+    marker.setMapboxMap(mapboxMap);
+    long id = nativeMapView.addMarker(marker);
+    marker.setId(id);
+    annotations.put(id, marker);
+    return marker;
+  }
+
+  public MarkerView addMarker(@NonNull BaseMarkerViewOptions markerOptions, @NonNull MapboxMap mapboxMap,
+                              final MarkerViewManager.OnMarkerViewAddedListener onMarkerViewAddedListener) {
+    final MarkerView marker = prepareViewMarker(markerOptions);
+
+    // add marker to map
+    marker.setMapboxMap(mapboxMap);
+    long id = nativeMapView.addMarker(marker);
+    marker.setId(id);
+    annotations.put(id, marker);
+
+    markerViewManager.addOnMarkerViewAddedListener(marker, onMarkerViewAddedListener);
+    markerViewManager.setWaitingForRenderInvoke(true);
+    return marker;
+  }
+
+
+  List<MarkerView> addMarkerViews(@NonNull List<? extends BaseMarkerViewOptions> markerViewOptions,
+                                  @NonNull MapboxMap mapboxMap) {
+    List<MarkerView> markers = new ArrayList<>();
+    for (BaseMarkerViewOptions markerViewOption : markerViewOptions) {
+      // if last marker
+      if (markerViewOptions.indexOf(markerViewOption) == markerViewOptions.size() - 1) {
+        // get notified when render occurs to invalidate and draw MarkerViews
+        markerViewManager.setWaitingForRenderInvoke(true);
+      }
+      // add marker to map
+      MarkerView marker = prepareViewMarker(markerViewOption);
+      marker.setMapboxMap(mapboxMap);
+      long id = nativeMapView.addMarker(marker);
+      marker.setId(id);
+      annotations.put(id, marker);
+      markers.add(marker);
     }
+    markerViewManager.invalidateViewMarkersInVisibleRegion();
+    return markers;
+  }
 
-    List<Marker> addMarkers(@NonNull List<? extends BaseMarkerOptions> markerOptionsList, @NonNull MapboxMap mapboxMap) {
-        int count = markerOptionsList.size();
-        List<Marker> markers = new ArrayList<>(count);
-        if (count > 0) {
-            BaseMarkerOptions markerOptions;
-            Marker marker;
-            for (int i = 0; i < count; i++) {
-                markerOptions = markerOptionsList.get(i);
-                marker = prepareMarker(markerOptions);
-                markers.add(marker);
-            }
-
-            if (markers.size() > 0) {
-                long[] ids = null;
-                if (nativeMapView != null) {
-                    ids = nativeMapView.addMarkers(markers);
-                }
-
-                long id = 0;
-                Marker m;
-                for (int i = 0; i < markers.size(); i++) {
-                    m = markers.get(i);
-                    m.setMapboxMap(mapboxMap);
-                    if (ids != null) {
-                        id = ids[i];
-                    } else {
-                        //unit test
-                        id++;
-                    }
-                    m.setId(id);
-                    annotations.put(id, m);
-                }
-
-            }
-        }
-        return markers;
-    }
+  private MarkerView prepareViewMarker(BaseMarkerViewOptions markerViewOptions) {
+    MarkerView marker = markerViewOptions.getMarker();
+    iconManager.loadIconForMarkerView(marker);
+    return marker;
+  }
 
-    private Marker prepareMarker(BaseMarkerOptions markerOptions) {
-        Marker marker = markerOptions.getMarker();
-        Icon icon = iconManager.loadIconForMarker(marker);
-        marker.setTopOffsetPixels(iconManager.getTopOffsetPixelsForIcon(icon));
-        return marker;
+  void updateMarker(@NonNull Marker updatedMarker, @NonNull MapboxMap mapboxMap) {
+    if (updatedMarker == null) {
+      return;
     }
 
-    MarkerView addMarker(@NonNull BaseMarkerViewOptions markerOptions, @NonNull MapboxMap mapboxMap) {
-        MarkerView marker = prepareViewMarker(markerOptions);
-        marker.setMapboxMap(mapboxMap);
-        long id = nativeMapView.addMarker(marker);
-        marker.setId(id);
-        annotations.put(id, marker);
-        return marker;
+    if (updatedMarker.getId() == -1) {
+      return;
     }
 
-    public MarkerView addMarker(@NonNull BaseMarkerViewOptions markerOptions, @NonNull MapboxMap mapboxMap, final MarkerViewManager.OnMarkerViewAddedListener onMarkerViewAddedListener) {
-        final MarkerView marker = prepareViewMarker(markerOptions);
-
-        // add marker to map
-        marker.setMapboxMap(mapboxMap);
-        long id = nativeMapView.addMarker(marker);
-        marker.setId(id);
-        annotations.put(id, marker);
-
-        markerViewManager.addOnMarkerViewAddedListener(marker, onMarkerViewAddedListener);
-        markerViewManager.setWaitingForRenderInvoke(true);
-        return marker;
+    if (!(updatedMarker instanceof MarkerView)) {
+      iconManager.ensureIconLoaded(updatedMarker, mapboxMap);
     }
 
+    nativeMapView.updateMarker(updatedMarker);
 
-    List<MarkerView> addMarkerViews(@NonNull List<? extends BaseMarkerViewOptions> markerViewOptions, @NonNull MapboxMap mapboxMap) {
-        List<MarkerView> markers = new ArrayList<>();
-        for (BaseMarkerViewOptions markerViewOption : markerViewOptions) {
-            // if last marker
-            if (markerViewOptions.indexOf(markerViewOption) == markerViewOptions.size() - 1) {
-                // get notified when render occurs to invalidate and draw MarkerViews
-                markerViewManager.setWaitingForRenderInvoke(true);
-            }
-            // add marker to map
-            MarkerView marker = prepareViewMarker(markerViewOption);
-            marker.setMapboxMap(mapboxMap);
-            long id = nativeMapView.addMarker(marker);
-            marker.setId(id);
-            annotations.put(id, marker);
-            markers.add(marker);
-        }
-        markerViewManager.invalidateViewMarkersInVisibleRegion();
-        return markers;
+    int index = annotations.indexOfKey(updatedMarker.getId());
+    if (index > -1) {
+      annotations.setValueAt(index, updatedMarker);
     }
+  }
 
-    private MarkerView prepareViewMarker(BaseMarkerViewOptions markerViewOptions) {
-        MarkerView marker = markerViewOptions.getMarker();
-        iconManager.loadIconForMarkerView(marker);
-        return marker;
+  List<Marker> getMarkers() {
+    List<Marker> markers = new ArrayList<>();
+    Annotation annotation;
+    for (int i = 0; i < annotations.size(); i++) {
+      annotation = annotations.get(annotations.keyAt(i));
+      if (annotation instanceof Marker) {
+        markers.add((Marker) annotation);
+      }
     }
+    return markers;
+  }
 
-    void updateMarker(@NonNull Marker updatedMarker, @NonNull MapboxMap mapboxMap) {
-        if (updatedMarker == null) {
-            return;
-        }
-
-        if (updatedMarker.getId() == -1) {
-            return;
-        }
+  void setOnMarkerClickListener(@Nullable MapboxMap.OnMarkerClickListener listener) {
+    onMarkerClickListener = listener;
+  }
 
-        if (!(updatedMarker instanceof MarkerView)) {
-            iconManager.ensureIconLoaded(updatedMarker, mapboxMap);
-        }
-
-        nativeMapView.updateMarker(updatedMarker);
-
-        int index = annotations.indexOfKey(updatedMarker.getId());
-        if (index > -1) {
-            annotations.setValueAt(index, updatedMarker);
-        }
+  void selectMarker(@NonNull Marker marker) {
+    if (selectedMarkers.contains(marker)) {
+      return;
     }
 
-    List<Marker> getMarkers() {
-        List<Marker> markers = new ArrayList<>();
-        Annotation annotation;
-        for (int i = 0; i < annotations.size(); i++) {
-            annotation = annotations.get(annotations.keyAt(i));
-            if (annotation instanceof Marker) {
-                markers.add((Marker) annotation);
-            }
-        }
-        return markers;
+    // Need to deselect any currently selected annotation first
+    if (!infoWindowManager.isAllowConcurrentMultipleOpenInfoWindows()) {
+      deselectMarkers();
     }
 
-    void setOnMarkerClickListener(@Nullable MapboxMap.OnMarkerClickListener listener) {
-        onMarkerClickListener = listener;
+    if (marker instanceof MarkerView) {
+      markerViewManager.select((MarkerView) marker, false);
+      markerViewManager.ensureInfoWindowOffset((MarkerView) marker);
     }
 
-    void selectMarker(@NonNull Marker marker) {
-        if (selectedMarkers.contains(marker)) {
-            return;
-        }
-
-        // Need to deselect any currently selected annotation first
-        if (!infoWindowManager.isAllowConcurrentMultipleOpenInfoWindows()) {
-            deselectMarkers();
-        }
-
-        if (marker instanceof MarkerView) {
-            markerViewManager.select((MarkerView) marker, false);
-            markerViewManager.ensureInfoWindowOffset((MarkerView) marker);
-        }
+    if (infoWindowManager.isInfoWindowValidForMarker(marker) || infoWindowManager.getInfoWindowAdapter() != null) {
+      infoWindowManager.add(marker.showInfoWindow(mapboxMap, mapView));
+    }
 
-        if (infoWindowManager.isInfoWindowValidForMarker(marker) || infoWindowManager.getInfoWindowAdapter() != null) {
-            infoWindowManager.add(marker.showInfoWindow(mapboxMap, mapView));
-        }
+    // only add to selected markers if user didn't handle the click event themselves #3176
+    selectedMarkers.add(marker);
+  }
 
-        // only add to selected markers if user didn't handle the click event themselves #3176
-        selectedMarkers.add(marker);
+  void deselectMarkers() {
+    if (selectedMarkers.isEmpty()) {
+      return;
     }
 
-    void deselectMarkers() {
-        if (selectedMarkers.isEmpty()) {
-            return;
-        }
+    for (Marker marker : selectedMarkers) {
+      if (marker.isInfoWindowShown()) {
+        marker.hideInfoWindow();
+      }
 
-        for (Marker marker : selectedMarkers) {
-            if (marker.isInfoWindowShown()) {
-                marker.hideInfoWindow();
-            }
-
-            if (marker instanceof MarkerView) {
-                markerViewManager.deselect((MarkerView) marker, false);
-            }
-        }
-
-        // Removes all selected markers from the list
-        selectedMarkers.clear();
+      if (marker instanceof MarkerView) {
+        markerViewManager.deselect((MarkerView) marker, false);
+      }
     }
 
-    void deselectMarker(@NonNull Marker marker) {
-        if (!selectedMarkers.contains(marker)) {
-            return;
-        }
-
-        if (marker.isInfoWindowShown()) {
-            marker.hideInfoWindow();
-        }
+    // Removes all selected markers from the list
+    selectedMarkers.clear();
+  }
 
-        if (marker instanceof MarkerView) {
-            markerViewManager.deselect((MarkerView) marker, false);
-        }
+  void deselectMarker(@NonNull Marker marker) {
+    if (!selectedMarkers.contains(marker)) {
+      return;
+    }
 
-        selectedMarkers.remove(marker);
+    if (marker.isInfoWindowShown()) {
+      marker.hideInfoWindow();
     }
 
-    List<Marker> getSelectedMarkers() {
-        return selectedMarkers;
+    if (marker instanceof MarkerView) {
+      markerViewManager.deselect((MarkerView) marker, false);
     }
 
-    public List<Marker> getMarkersInRect(@NonNull RectF rectangle) {
-        // convert Rectangle to be density depedent
-        float pixelRatio = nativeMapView.getPixelRatio();
-        RectF rect = new RectF(rectangle.left / pixelRatio,
-                rectangle.top / pixelRatio,
-                rectangle.right / pixelRatio,
-                rectangle.bottom / pixelRatio);
+    selectedMarkers.remove(marker);
+  }
 
-        long[] ids = nativeMapView.queryPointAnnotations(rect);
+  List<Marker> getSelectedMarkers() {
+    return selectedMarkers;
+  }
 
-        List<Long> idsList = new ArrayList<>(ids.length);
-        for (long id : ids) {
-            idsList.add(id);
-        }
+  public List<Marker> getMarkersInRect(@NonNull RectF rectangle) {
+    // convert Rectangle to be density depedent
+    float pixelRatio = nativeMapView.getPixelRatio();
+    RectF rect = new RectF(rectangle.left / pixelRatio,
+      rectangle.top / pixelRatio,
+      rectangle.right / pixelRatio,
+      rectangle.bottom / pixelRatio);
 
-        List<Marker> annotations = new ArrayList<>(ids.length);
-        List<Annotation> annotationList = getAnnotations();
-        int count = annotationList.size();
-        for (int i = 0; i < count; i++) {
-            Annotation annotation = annotationList.get(i);
-            if (annotation instanceof com.mapbox.mapboxsdk.annotations.Marker && idsList.contains(annotation.getId())) {
-                annotations.add((com.mapbox.mapboxsdk.annotations.Marker) annotation);
-            }
-        }
+    long[] ids = nativeMapView.queryPointAnnotations(rect);
 
-        return new ArrayList<>(annotations);
+    List<Long> idsList = new ArrayList<>(ids.length);
+    for (long id : ids) {
+      idsList.add(id);
     }
 
-    public List<MarkerView> getMarkerViewsInRect(@NonNull RectF rectangle) {
-        float pixelRatio = nativeMapView.getPixelRatio();
-        RectF rect = new RectF(rectangle.left / pixelRatio,
-                rectangle.top / pixelRatio,
-                rectangle.right / pixelRatio,
-                rectangle.bottom / pixelRatio);
+    List<Marker> annotations = new ArrayList<>(ids.length);
+    List<Annotation> annotationList = getAnnotations();
+    int count = annotationList.size();
+    for (int i = 0; i < count; i++) {
+      Annotation annotation = annotationList.get(i);
+      if (annotation instanceof com.mapbox.mapboxsdk.annotations.Marker && idsList.contains(annotation.getId())) {
+        annotations.add((com.mapbox.mapboxsdk.annotations.Marker) annotation);
+      }
+    }
 
-        long[] ids = nativeMapView.queryPointAnnotations(rect);
+    return new ArrayList<>(annotations);
+  }
 
-        List<Long> idsList = new ArrayList<>(ids.length);
-        for (long id : ids) {
-            idsList.add(id);
-        }
+  public List<MarkerView> getMarkerViewsInRect(@NonNull RectF rectangle) {
+    float pixelRatio = nativeMapView.getPixelRatio();
+    RectF rect = new RectF(rectangle.left / pixelRatio,
+      rectangle.top / pixelRatio,
+      rectangle.right / pixelRatio,
+      rectangle.bottom / pixelRatio);
 
-        List<MarkerView> annotations = new ArrayList<>(ids.length);
-        List<Annotation> annotationList = getAnnotations();
-        int count = annotationList.size();
-        for (int i = 0; i < count; i++) {
-            Annotation annotation = annotationList.get(i);
-            if (annotation instanceof MarkerView && idsList.contains(annotation.getId())) {
-                annotations.add((MarkerView) annotation);
-            }
-        }
+    long[] ids = nativeMapView.queryPointAnnotations(rect);
 
-        return new ArrayList<>(annotations);
+    List<Long> idsList = new ArrayList<>(ids.length);
+    for (long id : ids) {
+      idsList.add(id);
     }
 
-    //
-    // Polygons
-    //
-
-    Polygon addPolygon(@NonNull PolygonOptions polygonOptions, @NonNull MapboxMap mapboxMap) {
-        Polygon polygon = polygonOptions.getPolygon();
-        if (!polygon.getPoints().isEmpty()) {
-            long id = nativeMapView != null ? nativeMapView.addPolygon(polygon) : 0;
-            polygon.setId(id);
-            polygon.setMapboxMap(mapboxMap);
-            annotations.put(id, polygon);
-        }
-        return polygon;
+    List<MarkerView> annotations = new ArrayList<>(ids.length);
+    List<Annotation> annotationList = getAnnotations();
+    int count = annotationList.size();
+    for (int i = 0; i < count; i++) {
+      Annotation annotation = annotationList.get(i);
+      if (annotation instanceof MarkerView && idsList.contains(annotation.getId())) {
+        annotations.add((MarkerView) annotation);
+      }
     }
 
-    List<Polygon> addPolygons(@NonNull List<PolygonOptions> polygonOptionsList, @NonNull MapboxMap mapboxMap) {
-        int count = polygonOptionsList.size();
-
-        Polygon polygon;
-        List<Polygon> polygons = new ArrayList<>(count);
-        if (count > 0) {
-            for (PolygonOptions polygonOptions : polygonOptionsList) {
-                polygon = polygonOptions.getPolygon();
-                if (!polygon.getPoints().isEmpty()) {
-                    polygons.add(polygon);
-                }
-            }
+    return new ArrayList<>(annotations);
+  }
 
-            long[] ids = null;
-            if (nativeMapView != null) {
-                ids = nativeMapView.addPolygons(polygons);
-            }
+  //
+  // Polygons
+  //
 
-            long id = 0;
-            for (int i = 0; i < polygons.size(); i++) {
-                polygon = polygons.get(i);
-                polygon.setMapboxMap(mapboxMap);
-                if (ids != null) {
-                    id = ids[i];
-                } else {
-                    // unit test
-                    id++;
-                }
-                polygon.setId(id);
-                annotations.put(id, polygon);
-            }
-        }
-        return polygons;
+  Polygon addPolygon(@NonNull PolygonOptions polygonOptions, @NonNull MapboxMap mapboxMap) {
+    Polygon polygon = polygonOptions.getPolygon();
+    if (!polygon.getPoints().isEmpty()) {
+      long id = nativeMapView != null ? nativeMapView.addPolygon(polygon) : 0;
+      polygon.setId(id);
+      polygon.setMapboxMap(mapboxMap);
+      annotations.put(id, polygon);
     }
+    return polygon;
+  }
 
-    void updatePolygon(Polygon polygon) {
-        if (polygon == null) {
-            return;
-        }
+  List<Polygon> addPolygons(@NonNull List<PolygonOptions> polygonOptionsList, @NonNull MapboxMap mapboxMap) {
+    int count = polygonOptionsList.size();
 
-        if (polygon.getId() == -1) {
-            return;
+    Polygon polygon;
+    List<Polygon> polygons = new ArrayList<>(count);
+    if (count > 0) {
+      for (PolygonOptions polygonOptions : polygonOptionsList) {
+        polygon = polygonOptions.getPolygon();
+        if (!polygon.getPoints().isEmpty()) {
+          polygons.add(polygon);
         }
+      }
 
-        nativeMapView.updatePolygon(polygon);
+      long[] ids = null;
+      if (nativeMapView != null) {
+        ids = nativeMapView.addPolygons(polygons);
+      }
 
-        int index = annotations.indexOfKey(polygon.getId());
-        if (index > -1) {
-            annotations.setValueAt(index, polygon);
+      long id = 0;
+      for (int i = 0; i < polygons.size(); i++) {
+        polygon = polygons.get(i);
+        polygon.setMapboxMap(mapboxMap);
+        if (ids != null) {
+          id = ids[i];
+        } else {
+          // unit test
+          id++;
         }
+        polygon.setId(id);
+        annotations.put(id, polygon);
+      }
     }
+    return polygons;
+  }
 
-    List<Polygon> getPolygons() {
-        List<Polygon> polygons = new ArrayList<>();
-        Annotation annotation;
-        for (int i = 0; i < annotations.size(); i++) {
-            annotation = annotations.get(annotations.keyAt(i));
-            if (annotation instanceof Polygon) {
-                polygons.add((Polygon) annotation);
-            }
-        }
-        return polygons;
+  void updatePolygon(Polygon polygon) {
+    if (polygon == null) {
+      return;
     }
 
-    //
-    // Polylines
-    //
-
-    Polyline addPolyline(@NonNull PolylineOptions polylineOptions, @NonNull MapboxMap mapboxMap) {
-        Polyline polyline = polylineOptions.getPolyline();
-        if (!polyline.getPoints().isEmpty()) {
-            long id = nativeMapView != null ? nativeMapView.addPolyline(polyline) : 0;
-            polyline.setMapboxMap(mapboxMap);
-            polyline.setId(id);
-            annotations.put(id, polyline);
-        }
-        return polyline;
+    if (polygon.getId() == -1) {
+      return;
     }
 
-    List<Polyline> addPolylines(@NonNull List<PolylineOptions> polylineOptionsList, @NonNull MapboxMap mapboxMap) {
-        int count = polylineOptionsList.size();
-        Polyline polyline;
-        List<Polyline> polylines = new ArrayList<>(count);
+    nativeMapView.updatePolygon(polygon);
 
-        if (count > 0) {
-            for (PolylineOptions options : polylineOptionsList) {
-                polyline = options.getPolyline();
-                if (!polyline.getPoints().isEmpty()) {
-                    polylines.add(polyline);
-                }
-            }
-
-            long[] ids = null;
-            if (nativeMapView != null) {
-                ids = nativeMapView.addPolylines(polylines);
-            }
-
-            long id = 0;
-            Polyline p;
-
-            for (int i = 0; i < polylines.size(); i++) {
-                p = polylines.get(i);
-                p.setMapboxMap(mapboxMap);
-                if (ids != null) {
-                    id = ids[i];
-                } else {
-                    // unit test
-                    id++;
-                }
-                p.setId(id);
-                annotations.put(id, p);
-            }
-        }
-        return polylines;
+    int index = annotations.indexOfKey(polygon.getId());
+    if (index > -1) {
+      annotations.setValueAt(index, polygon);
     }
+  }
 
-    void updatePolyline(Polyline polyline) {
-        if (polyline == null) {
-            return;
-        }
-
-        if (polyline.getId() == -1) {
-            return;
-        }
-
-        nativeMapView.updatePolyline(polyline);
-
-        int index = annotations.indexOfKey(polyline.getId());
-        if (index > -1) {
-            annotations.setValueAt(index, polyline);
-        }
+  List<Polygon> getPolygons() {
+    List<Polygon> polygons = new ArrayList<>();
+    Annotation annotation;
+    for (int i = 0; i < annotations.size(); i++) {
+      annotation = annotations.get(annotations.keyAt(i));
+      if (annotation instanceof Polygon) {
+        polygons.add((Polygon) annotation);
+      }
     }
+    return polygons;
+  }
 
-    List<Polyline> getPolylines() {
-        List<Polyline> polylines = new ArrayList<>();
-        Annotation annotation;
-        for (int i = 0; i < annotations.size(); i++) {
-            annotation = annotations.get(annotations.keyAt(i));
-            if (annotation instanceof Polyline) {
-                polylines.add((Polyline) annotation);
-            }
-        }
-        return polylines;
-    }
+  //
+  // Polylines
+  //
 
-    InfoWindowManager getInfoWindowManager() {
-        return infoWindowManager;
+  Polyline addPolyline(@NonNull PolylineOptions polylineOptions, @NonNull MapboxMap mapboxMap) {
+    Polyline polyline = polylineOptions.getPolyline();
+    if (!polyline.getPoints().isEmpty()) {
+      long id = nativeMapView != null ? nativeMapView.addPolyline(polyline) : 0;
+      polyline.setMapboxMap(mapboxMap);
+      polyline.setId(id);
+      annotations.put(id, polyline);
     }
+    return polyline;
+  }
 
-    MarkerViewManager getMarkerViewManager() {
-        return markerViewManager;
-    }
-
-    void adjustTopOffsetPixels(MapboxMap mapboxMap) {
-        int count = annotations.size();
-        for (int i = 0; i < count; i++) {
-            Annotation annotation = annotations.get(i);
-            if (annotation instanceof Marker) {
-                Marker marker = (Marker) annotation;
-                marker.setTopOffsetPixels(
-                        iconManager.getTopOffsetPixelsForIcon(marker.getIcon()));
-            }
-        }
+  List<Polyline> addPolylines(@NonNull List<PolylineOptions> polylineOptionsList, @NonNull MapboxMap mapboxMap) {
+    int count = polylineOptionsList.size();
+    Polyline polyline;
+    List<Polyline> polylines = new ArrayList<>(count);
 
-        for (Marker marker : selectedMarkers) {
-            if (marker.isInfoWindowShown()) {
-                marker.hideInfoWindow();
-                marker.showInfoWindow(mapboxMap, mapView);
-            }
+    if (count > 0) {
+      for (PolylineOptions options : polylineOptionsList) {
+        polyline = options.getPolyline();
+        if (!polyline.getPoints().isEmpty()) {
+          polylines.add(polyline);
         }
-    }
+      }
+
+      long[] ids = null;
+      if (nativeMapView != null) {
+        ids = nativeMapView.addPolylines(polylines);
+      }
+
+      long id = 0;
+      Polyline p;
+
+      for (int i = 0; i < polylines.size(); i++) {
+        p = polylines.get(i);
+        p.setMapboxMap(mapboxMap);
+        if (ids != null) {
+          id = ids[i];
+        } else {
+          // unit test
+          id++;
+        }
+        p.setId(id);
+        annotations.put(id, p);
+      }
+    }
+    return polylines;
+  }
+
+  void updatePolyline(Polyline polyline) {
+    if (polyline == null) {
+      return;
+    }
+
+    if (polyline.getId() == -1) {
+      return;
+    }
+
+    nativeMapView.updatePolyline(polyline);
+
+    int index = annotations.indexOfKey(polyline.getId());
+    if (index > -1) {
+      annotations.setValueAt(index, polyline);
+    }
+  }
+
+  List<Polyline> getPolylines() {
+    List<Polyline> polylines = new ArrayList<>();
+    Annotation annotation;
+    for (int i = 0; i < annotations.size(); i++) {
+      annotation = annotations.get(annotations.keyAt(i));
+      if (annotation instanceof Polyline) {
+        polylines.add((Polyline) annotation);
+      }
+    }
+    return polylines;
+  }
+
+  InfoWindowManager getInfoWindowManager() {
+    return infoWindowManager;
+  }
+
+  MarkerViewManager getMarkerViewManager() {
+    return markerViewManager;
+  }
+
+  void adjustTopOffsetPixels(MapboxMap mapboxMap) {
+    int count = annotations.size();
+    for (int i = 0; i < count; i++) {
+      Annotation annotation = annotations.get(i);
+      if (annotation instanceof Marker) {
+        Marker marker = (Marker) annotation;
+        marker.setTopOffsetPixels(
+          iconManager.getTopOffsetPixelsForIcon(marker.getIcon()));
+      }
+    }
+
+    for (Marker marker : selectedMarkers) {
+      if (marker.isInfoWindowShown()) {
+        marker.hideInfoWindow();
+        marker.showInfoWindow(mapboxMap, mapView);
+      }
+    }
+  }
+
+  void reloadMarkers() {
+    iconManager.reloadIcons();
+    int count = annotations.size();
+    for (int i = 0; i < count; i++) {
+      Annotation annotation = annotations.get(i);
+      if (annotation instanceof Marker) {
+        Marker marker = (Marker) annotation;
+        nativeMapView.removeAnnotation(annotation.getId());
+        long newId = nativeMapView.addMarker(marker);
+        marker.setId(newId);
+      }
+    }
+  }
+
+  //
+  // Click event
+  //
+
+  boolean onTap(PointF tapPoint, float screenDensity) {
+    float toleranceSides = 4 * screenDensity;
+    float toleranceTopBottom = 10 * screenDensity;
+
+    RectF tapRect = new RectF(tapPoint.x - iconManager.getAverageIconWidth() / 2 - toleranceSides,
+      tapPoint.y - iconManager.getAverageIconHeight() / 2 - toleranceTopBottom,
+      tapPoint.x + iconManager.getAverageIconWidth() / 2 + toleranceSides,
+      tapPoint.y + iconManager.getAverageIconHeight() / 2 + toleranceTopBottom);
+
+    List<Marker> nearbyMarkers = getMarkersInRect(tapRect);
+    long newSelectedMarkerId = -1;
+
+    if (nearbyMarkers != null && nearbyMarkers.size() > 0) {
+      Collections.sort(nearbyMarkers);
+      for (Marker nearbyMarker : nearbyMarkers) {
+        boolean found = false;
+        for (Marker selectedMarker : selectedMarkers) {
+          if (selectedMarker.equals(nearbyMarker)) {
+            found = true;
+          }
+        }
+        if (!found) {
+          newSelectedMarkerId = nearbyMarker.getId();
+          break;
+        }
+      }
+    }
+
+    if (newSelectedMarkerId >= 0) {
+      List<Annotation> annotations = getAnnotations();
+      int count = annotations.size();
+      for (int i = 0; i < count; i++) {
+        Annotation annotation = annotations.get(i);
+        if (annotation instanceof Marker) {
+          if (annotation.getId() == newSelectedMarkerId) {
+            Marker marker = (Marker) annotation;
+            boolean handledDefaultClick = false;
 
-    void reloadMarkers() {
-        iconManager.reloadIcons();
-        int count = annotations.size();
-        for (int i = 0; i < count; i++) {
-            Annotation annotation = annotations.get(i);
-            if (annotation instanceof Marker) {
-                Marker marker = (Marker) annotation;
-                nativeMapView.removeAnnotation(annotation.getId());
-                long newId = nativeMapView.addMarker(marker);
-                marker.setId(newId);
+            if (marker instanceof MarkerView) {
+              handledDefaultClick = markerViewManager.onClickMarkerView((MarkerView) marker);
+            } else {
+              if (onMarkerClickListener != null) {
+                // end developer has provided a custom click listener
+                handledDefaultClick = onMarkerClickListener.onMarkerClick(marker);
+              }
             }
-        }
-    }
 
-    //
-    // Click event
-    //
-
-    boolean onTap(PointF tapPoint, float screenDensity) {
-        float toleranceSides = 4 * screenDensity;
-        float toleranceTopBottom = 10 * screenDensity;
-
-        RectF tapRect = new RectF(tapPoint.x - iconManager.getAverageIconWidth() / 2 - toleranceSides,
-                tapPoint.y - iconManager.getAverageIconHeight() / 2 - toleranceTopBottom,
-                tapPoint.x + iconManager.getAverageIconWidth() / 2 + toleranceSides,
-                tapPoint.y + iconManager.getAverageIconHeight() / 2 + toleranceTopBottom);
-
-        List<Marker> nearbyMarkers = getMarkersInRect(tapRect);
-        long newSelectedMarkerId = -1;
-
-        if (nearbyMarkers != null && nearbyMarkers.size() > 0) {
-            Collections.sort(nearbyMarkers);
-            for (Marker nearbyMarker : nearbyMarkers) {
-                boolean found = false;
-                for (Marker selectedMarker : selectedMarkers) {
-                    if (selectedMarker.equals(nearbyMarker)) {
-                        found = true;
-                    }
-                }
-                if (!found) {
-                    newSelectedMarkerId = nearbyMarker.getId();
-                    break;
-                }
+            if (annotation instanceof MarkerView) {
+              markerViewManager.onClickMarkerView((MarkerView) annotation);
+            } else {
+              if (!handledDefaultClick) {
+                // only select marker if user didn't handle the click event themselves
+                selectMarker(marker);
+              }
             }
-        }
 
-        if (newSelectedMarkerId >= 0) {
-            List<Annotation> annotations = getAnnotations();
-            int count = annotations.size();
-            for (int i = 0; i < count; i++) {
-                Annotation annotation = annotations.get(i);
-                if (annotation instanceof Marker) {
-                    if (annotation.getId() == newSelectedMarkerId) {
-                        Marker marker = (Marker) annotation;
-                        boolean handledDefaultClick = false;
-
-                        if (marker instanceof MarkerView) {
-                            handledDefaultClick = markerViewManager.onClickMarkerView((MarkerView) marker);
-                        } else {
-                            if (onMarkerClickListener != null) {
-                                // end developer has provided a custom click listener
-                                handledDefaultClick = onMarkerClickListener.onMarkerClick(marker);
-                            }
-                        }
-
-                        if (annotation instanceof MarkerView) {
-                            markerViewManager.onClickMarkerView((MarkerView) annotation);
-                        } else {
-                            if (!handledDefaultClick) {
-                                // only select marker if user didn't handle the click event themselves
-                                selectMarker(marker);
-                            }
-                        }
-
-                        return true;
-                    }
-                }
-            }
+            return true;
+          }
         }
-        return false;
+      }
     }
+    return false;
+  }
 }