[android] #3753 - Optimising zoom

[android] #3753 - removed old zoom methods from MapView

5 files changed, 309 insertions, 127 deletions

diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/camera/CameraUpdateFactory.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/camera/CameraUpdateFactory.java
index 6f39f8b7cc..73986c8971 100644
--- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/camera/CameraUpdateFactory.java
+++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/camera/CameraUpdateFactory.java
@@ -93,7 +93,7 @@ public class CameraUpdateFactory {
      * @return
      */
     public static CameraUpdate zoomBy(float amount, Point focus) {
-        return new ZoomUpdate(ZoomUpdate.ZOOM_TO_POINT, focus.x, focus.y);
+        return new ZoomUpdate(amount, focus.x, focus.y);
     }
 
     /**
diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapView.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapView.java
index a62bb1e862..66d344312f 100644
--- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapView.java
+++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapView.java
@@ -611,7 +611,7 @@ public class MapView extends FrameLayout {
     void setDirection(@FloatRange(from = MapboxConstants.MINIMUM_DIRECTION, to = MapboxConstants.MAXIMUM_DIRECTION) double direction, boolean animated) {
         long duration = animated ? MapboxConstants.ANIMATION_DURATION : 0;
         mNativeMapView.cancelTransitions();
-        // Out of range direactions are normallised in setBearing
+        // Out of range directions are normalised in setBearing
         mNativeMapView.setBearing(-direction, duration);
     }
 
@@ -639,105 +639,6 @@ public class MapView extends FrameLayout {
         return mNativeMapView.getZoom();
     }
 
-    /**
-     * <p>
-     * Zooms the map to a new zoom level immediately without changing the center coordinate.
-     * </p>
-     * <p>
-     * At zoom level 0, tiles cover the entire world map;
-     * at zoom level 1, tiles cover 1/14 of the world;
-     * at zoom level 2, tiles cover 1/16 of the world, and so on.
-     * </p>
-     * <p>
-     * The initial zoom level is 0. The maximum zoom level is {@link MapboxConstants#MAXIMUM_ZOOM}.
-     * </p>
-     * If you want to animate the change, use {@link MapView#setZoom(double, boolean)}.
-     *
-     * @param zoomLevel The new zoom.
-     * @see MapView#setZoom(double, boolean)
-     * @see MapboxConstants#MAXIMUM_ZOOM
-     */
-    @UiThread
-    void setZoom(@FloatRange(from = MapboxConstants.MINIMUM_ZOOM, to = MapboxConstants.MAXIMUM_ZOOM) double zoomLevel) {
-        setZoom(zoomLevel, false);
-    }
-
-    /**
-     * <p>
-     * Zooms the map to a new zoom level and optionally animates the change without changing the center coordinate.
-     * </p>
-     * <p>
-     * At zoom level 0, tiles cover the entire world map;
-     * at zoom level 1, tiles cover 1/14 of the world;
-     * at zoom level 2, tiles cover 1/16 of the world, and so on.
-     * </p>
-     * The initial zoom level is 0. The maximum zoom level is {@link MapboxConstants#MAXIMUM_ZOOM}.
-     *
-     * @param zoomLevel The new zoom level.
-     * @param animated  If true, animates the change. If false, immediately changes the map.
-     * @see MapboxConstants#MAXIMUM_ZOOM
-     */
-    @UiThread
-    void setZoom(@FloatRange(from = MapboxConstants.MINIMUM_ZOOM, to = MapboxConstants.MAXIMUM_ZOOM) double zoomLevel, boolean animated) {
-        long duration = animated ? MapboxConstants.ANIMATION_DURATION : 0;
-        setZoom(zoomLevel, duration);
-    }
-
-    /**
-     * <p>
-     * Zooms the map to a new zoom level and optionally animates the change without changing the center coordinate.
-     * </p>
-     * <p>
-     * At zoom level 0, tiles cover the entire world map;
-     * at zoom level 1, tiles cover 1/14 of the world;
-     * at zoom level 2, tiles cover 1/16 of the world, and so on.
-     * </p>
-     * The initial zoom level is 0. The maximum zoom level is {@link MapboxConstants#MAXIMUM_ZOOM}.
-     *
-     * @param zoomLevel The new zoom level.
-     * @param duration  The length of the animation.
-     * @see MapboxConstants#MAXIMUM_ZOOM
-     */
-    @UiThread
-    void setZoom(@FloatRange(from = MapboxConstants.MINIMUM_ZOOM, to = MapboxConstants.MAXIMUM_ZOOM) double zoomLevel, long duration) {
-        if ((zoomLevel < MapboxConstants.MINIMUM_ZOOM) || (zoomLevel > MapboxConstants.MAXIMUM_ZOOM)) {
-            Log.w(TAG, "Not setting zoom, value is in a unsupported range: " + zoomLevel);
-            return;
-        }
-        mNativeMapView.cancelTransitions();
-        mNativeMapView.setZoom(zoomLevel, duration);
-    }
-
-    void setZoom(@FloatRange(from = MapboxConstants.MINIMUM_ZOOM, to = MapboxConstants.MAXIMUM_ZOOM) double zoomLevel, float x, float y) {
-        if ((zoomLevel < MapboxConstants.MINIMUM_ZOOM) || (zoomLevel > MapboxConstants.MAXIMUM_ZOOM)) {
-            Log.w(TAG, "Not setting zoom, value is in a unsupported range: " + zoomLevel);
-            return;
-        }
-        LatLng target = fromScreenLocation(new PointF(x, y));
-        flyTo(-1, target, MapboxConstants.ANIMATION_DURATION, -1, zoomLevel, null);
-    }
-
-    void setZoom(CameraUpdateFactory.ZoomUpdate update, long duration) {
-        switch (update.getType()) {
-            case CameraUpdateFactory.ZoomUpdate.ZOOM_IN:
-                setZoom(getZoom() + 1, duration);
-                break;
-            case CameraUpdateFactory.ZoomUpdate.ZOOM_OUT:
-                setZoom(getZoom() - 1, duration);
-                break;
-            case CameraUpdateFactory.ZoomUpdate.ZOOM_TO:
-                setZoom(update.getZoom(), duration);
-                break;
-            case CameraUpdateFactory.ZoomUpdate.ZOOM_BY:
-                setZoom(getZoom() + update.getZoom(), duration);
-                break;
-            case CameraUpdateFactory.ZoomUpdate.ZOOM_TO_POINT:
-                setZoom(update.getZoom(), update.getX(), update.getY());
-                break;
-        }
-    }
-
-
 //    /**
 //     * Return The current content padding left of the map view viewport.
 //     *
diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapboxMap.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapboxMap.java
index da59d868e0..6076e9cd61 100644
--- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapboxMap.java
+++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapboxMap.java
@@ -115,14 +115,52 @@ public class MapboxMap {
      */
     @UiThread
     public final void moveCamera(CameraUpdate update) {
+        CameraPosition cameraPosition;
         if (update instanceof CameraUpdateFactory.PositionCameraUpdate) {
             CameraUpdateFactory.PositionCameraUpdate positionCameraUpdate = (CameraUpdateFactory.PositionCameraUpdate) update;
-            CameraPosition cameraPosition = new CameraPosition.Builder(positionCameraUpdate).build();
-            updateCameraPosition(cameraPosition);
-            mMapView.jumpTo(cameraPosition.bearing, cameraPosition.target, cameraPosition.tilt, cameraPosition.zoom);
-        }else if (update instanceof CameraUpdateFactory.ZoomUpdate) {
-            mMapView.setZoom((CameraUpdateFactory.ZoomUpdate) update, 0);
+            cameraPosition = new CameraPosition.Builder(positionCameraUpdate).build();
+        } else if (update instanceof CameraUpdateFactory.ZoomUpdate) {
+            CameraUpdateFactory.ZoomUpdate zoomUpdate = (CameraUpdateFactory.ZoomUpdate) update;
+            if(zoomUpdate.getType()!= CameraUpdateFactory.ZoomUpdate.ZOOM_TO_POINT){
+                cameraPosition = new CameraPosition.Builder(mCurrentCameraPosition)
+                        .zoom(getZoom(zoomUpdate, mCurrentCameraPosition.zoom))
+                        .build();
+            }else{
+                cameraPosition = new CameraPosition.Builder(mCurrentCameraPosition)
+                        .zoom(getZoom(zoomUpdate, mCurrentCameraPosition.zoom))
+                        .target(fromScreenLocation(new PointF(zoomUpdate.getX(),zoomUpdate.getY())))
+                        .build();
+            }
+        } else {
+            Log.e(MapboxConstants.TAG, "Unsupported CameraUpdate");
+            return;
         }
+        mCurrentCameraPosition = cameraPosition;
+        mMapView.jumpTo(cameraPosition.bearing, cameraPosition.target, cameraPosition.tilt, cameraPosition.zoom);
+    }
+
+    private float getZoom(CameraUpdateFactory.ZoomUpdate update, float currentZoom) {
+        switch (update.getType()) {
+            case CameraUpdateFactory.ZoomUpdate.ZOOM_IN:
+                currentZoom++;
+                break;
+            case CameraUpdateFactory.ZoomUpdate.ZOOM_OUT:
+                currentZoom--;
+                if (currentZoom < 0) {
+                    currentZoom = 0;
+                }
+                break;
+            case CameraUpdateFactory.ZoomUpdate.ZOOM_TO:
+                currentZoom = update.getZoom();
+                break;
+            case CameraUpdateFactory.ZoomUpdate.ZOOM_BY:
+                currentZoom = currentZoom + update.getZoom();
+                break;
+            case CameraUpdateFactory.ZoomUpdate.ZOOM_TO_POINT:
+                currentZoom = currentZoom + update.getZoom();
+                break;
+        }
+        return currentZoom;
     }
 
     /**
@@ -147,14 +185,28 @@ public class MapboxMap {
      */
     @UiThread
     public final void easeCamera(CameraUpdate update, int durationMs, final MapboxMap.CancelableCallback callback) {
+        CameraPosition cameraPosition;
         if (update instanceof CameraUpdateFactory.PositionCameraUpdate) {
             CameraUpdateFactory.PositionCameraUpdate positionCameraUpdate = (CameraUpdateFactory.PositionCameraUpdate) update;
-            CameraPosition cameraPosition = new CameraPosition.Builder(positionCameraUpdate).build();
-            updateCameraPosition(cameraPosition);
-            mMapView.easeTo(cameraPosition.bearing, cameraPosition.target, getDurationNano(durationMs), cameraPosition.tilt, cameraPosition.zoom, callback);
-        }else if (update instanceof CameraUpdateFactory.ZoomUpdate) {
-            mMapView.setZoom((CameraUpdateFactory.ZoomUpdate) update, durationMs);
+            cameraPosition = new CameraPosition.Builder(positionCameraUpdate).build();
+        } else if (update instanceof CameraUpdateFactory.ZoomUpdate) {
+            CameraUpdateFactory.ZoomUpdate zoomUpdate = (CameraUpdateFactory.ZoomUpdate) update;
+            if(zoomUpdate.getType()!= CameraUpdateFactory.ZoomUpdate.ZOOM_TO_POINT){
+                cameraPosition = new CameraPosition.Builder(mCurrentCameraPosition)
+                        .zoom(getZoom(zoomUpdate, mCurrentCameraPosition.zoom))
+                        .build();
+            }else{
+                cameraPosition = new CameraPosition.Builder(mCurrentCameraPosition)
+                        .zoom(getZoom(zoomUpdate, mCurrentCameraPosition.zoom))
+                        .target(fromScreenLocation(new PointF(zoomUpdate.getX(),zoomUpdate.getY())))
+                        .build();
+            }
+        } else {
+            Log.e(MapboxConstants.TAG, "Unsupported CameraUpdate");
+            return;
         }
+        mCurrentCameraPosition = cameraPosition;
+        mMapView.easeTo(cameraPosition.bearing, cameraPosition.target, getDurationNano(durationMs), cameraPosition.tilt, cameraPosition.zoom, callback);
     }
 
     /**
@@ -205,19 +257,28 @@ public class MapboxMap {
      */
     @UiThread
     public final void animateCamera(CameraUpdate update, int durationMs, final MapboxMap.CancelableCallback callback) {
+        CameraPosition cameraPosition;
         if (update instanceof CameraUpdateFactory.PositionCameraUpdate) {
             CameraUpdateFactory.PositionCameraUpdate positionCameraUpdate = (CameraUpdateFactory.PositionCameraUpdate) update;
-            CameraPosition cameraPosition = new CameraPosition.Builder(positionCameraUpdate).build();
-            updateCameraPosition(cameraPosition);
-            mMapView.flyTo(cameraPosition.bearing, cameraPosition.target, getDurationNano(durationMs), cameraPosition.tilt, cameraPosition.zoom, callback);
+            cameraPosition = new CameraPosition.Builder(positionCameraUpdate).build();
         } else if (update instanceof CameraUpdateFactory.ZoomUpdate) {
-            mMapView.setZoom((CameraUpdateFactory.ZoomUpdate) update, durationMs);
+            CameraUpdateFactory.ZoomUpdate zoomUpdate = (CameraUpdateFactory.ZoomUpdate) update;
+            if(zoomUpdate.getType()!= CameraUpdateFactory.ZoomUpdate.ZOOM_TO_POINT){
+                cameraPosition = new CameraPosition.Builder(mCurrentCameraPosition)
+                        .zoom(getZoom(zoomUpdate, mCurrentCameraPosition.zoom))
+                        .build();
+            }else {
+                cameraPosition = new CameraPosition.Builder(mCurrentCameraPosition)
+                        .zoom(getZoom(zoomUpdate, mCurrentCameraPosition.zoom))
+                        .target(fromScreenLocation(new PointF(zoomUpdate.getX(), zoomUpdate.getY())))
+                        .build();
+            }
+        } else {
+            Log.e(MapboxConstants.TAG, "Unsupported CameraUpdate");
+            return;
         }
-    }
-
-    // internal setter for CameraPosition
-    void updateCameraPosition(@NonNull CameraPosition cameraPosition) {
         mCurrentCameraPosition = cameraPosition;
+        mMapView.flyTo(cameraPosition.bearing, cameraPosition.target, getDurationNano(durationMs), cameraPosition.tilt, cameraPosition.zoom, callback);
     }
 
     // internal time layer conversion
diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/ManualZoomActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/ManualZoomActivity.java
index b0146fe73b..1f74d1e7f8 100644
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/ManualZoomActivity.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/ManualZoomActivity.java
@@ -82,7 +82,8 @@ public class ManualZoomActivity extends AppCompatActivity {
                 return true;
 
             case R.id.action_zoom_to_point:
-                mMapboxMap.animateCamera(CameraUpdateFactory.zoomBy(12, new Point(100, 100)));
+                View view = getWindow().getDecorView();
+                mMapboxMap.animateCamera(CameraUpdateFactory.zoomBy(1, new Point(view.getMeasuredWidth() / 4, view.getMeasuredHeight() / 4)));
                 return true;
 
             default:
diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.java
index 8677346336..b9677af002 100644
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.java
@@ -1,5 +1,7 @@
 package com.mapbox.mapboxsdk.maps;
 
+import android.graphics.Point;
+
 import com.mapbox.mapboxsdk.annotations.Marker;
 import com.mapbox.mapboxsdk.annotations.MarkerOptions;
 import com.mapbox.mapboxsdk.camera.CameraPosition;
@@ -45,6 +47,20 @@ public class MapboxMapTest {
         assertNotNull("mMapboxMap should not be null", mMapboxMap);
     }
 
+    //
+    // Test UiSettings
+    //
+
+    @Test
+    public void testUiSettings() {
+        assertNotNull("UiSettings should not be null", mMapboxMap.getUiSettings());
+    }
+
+
+    //
+    // InfoWindow
+    //
+
     @Test
     public void testConcurrentInfoWindowEnabled() {
         mMapboxMap.setAllowConcurrentMultipleOpenInfoWindows(true);
@@ -57,6 +73,10 @@ public class MapboxMapTest {
         assertFalse("ConcurrentWindows should be false", mMapboxMap.isAllowConcurrentMultipleOpenInfoWindows());
     }
 
+    //
+    // Location
+    //
+
     @Test
     public void testMyLocationEnabled() {
         try {
@@ -77,6 +97,10 @@ public class MapboxMapTest {
         }
     }
 
+    //
+    // Style
+    //
+
     @Test
     public void testStyleUrl() {
         mMapboxMap.setStyleUrl("somestyle");
@@ -89,6 +113,10 @@ public class MapboxMapTest {
         assertEquals("Style should be same", Style.MAPBOX_STREETS, mMapboxMap.getStyleUrl());
     }
 
+    //
+    // CameraPosition
+    //
+
     @Test
     public void testCameraPosition() {
         CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
@@ -96,55 +124,246 @@ public class MapboxMapTest {
         assertEquals("CameraPosition should be same", position, mMapboxMap.getCameraPosition());
     }
 
+    //
+    // Camera - moveCamera
+    //
+
     @Test
-    public void testMoveCamera() {
+    public void testNewCameraPositionMoveCamera() {
         CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
         mMapboxMap.moveCamera(CameraUpdateFactory.newCameraPosition(position));
         assertEquals("CameraPosition should be same", position, mMapboxMap.getCameraPosition());
     }
 
+    //
+    // Camera - animateCamera
+    //
+
     @Test
-    public void testAnimateCamera() {
+    public void testNewCameraPositionAnimateCamera() {
         CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
         mMapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(position));
         assertEquals("CameraPosition should be same", position, mMapboxMap.getCameraPosition());
     }
 
     @Test
-    public void testAnimateCameraWithCallbackParameter() {
+    public void testNewCameraPositionAnimateCameraWithCallbackParameter() {
         CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
         mMapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(position), null);
         assertEquals("CameraPosition should be same", position, mMapboxMap.getCameraPosition());
     }
 
     @Test
-    public void testAnimateCameraWithDurationParameter() {
+    public void testNewCameraPositionAnimateCameraWithDurationParameter() {
         CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
         mMapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(position), 0);
         assertEquals("CameraPosition should be same", position, mMapboxMap.getCameraPosition());
     }
 
     @Test
-    public void testAnimateCameraWithDurationAndCallbackParameter() {
+    public void testNewCameraPositionAnimateCameraWithDurationAndCallbackParameter() {
         CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
         mMapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(position), 0, null);
         assertEquals("CameraPosition should be same", position, mMapboxMap.getCameraPosition());
     }
 
+    //
+    // Camera - easeCamera
+    //
+
     @Test
-    public void testEaseCamera() {
+    public void testNewCameraPositionEaseCamera() {
         CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
         mMapboxMap.easeCamera(CameraUpdateFactory.newCameraPosition(position), 1000);
         assertEquals("CameraPosition should be same", position, mMapboxMap.getCameraPosition());
     }
 
     @Test
-    public void testEaseCameraWithCallbackParameter() {
+    public void testNewCameraPositionEaseCameraWithCallbackParameter() {
         CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
         mMapboxMap.easeCamera(CameraUpdateFactory.newCameraPosition(position), 1000, null);
         assertEquals("CameraPosition should be same", position, mMapboxMap.getCameraPosition());
     }
 
+    //
+    // Camera - LatLng
+    //
+
+    @Test
+    public void testLatLngMoveCamera() {
+        mMapboxMap.moveCamera(CameraUpdateFactory.newLatLng(new LatLng(4, 5)));
+        assertEquals("LatLng should be same", new LatLng(4, 5), mMapboxMap.getCameraPosition().target);
+    }
+
+    @Test
+    public void testLatLngAnimateCamera() {
+        mMapboxMap.animateCamera(CameraUpdateFactory.newLatLng(new LatLng(4, 5)));
+        assertEquals("LatLng should be same", new LatLng(4, 5), mMapboxMap.getCameraPosition().target);
+    }
+
+    @Test
+    public void testLatLngEaseCamera() {
+        mMapboxMap.easeCamera(CameraUpdateFactory.newLatLng(new LatLng(4, 5)), 1000);
+        assertEquals("LatLng should be same", new LatLng(4, 5), mMapboxMap.getCameraPosition().target);
+    }
+
+    //
+    // Camera - LatLngZoom
+    //
+
+    @Test
+    public void testLatLngZoomMoveCamera() {
+        mMapboxMap.moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(4, 5), 10));
+        assertEquals("LatLng should be same", new LatLng(4, 5), mMapboxMap.getCameraPosition().target);
+        assertTrue("Zoomlevel should be same", 10 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    @Test
+    public void testLatLngZoomAnimateCamera() {
+        mMapboxMap.animateCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(4, 5), 10));
+        assertEquals("LatLng should be same", new LatLng(4, 5), mMapboxMap.getCameraPosition().target);
+        assertTrue("Zoomlevel should be same", 10 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    @Test
+    public void testLatLngZoomEaseCamera() {
+        mMapboxMap.easeCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(4, 5), 10), 1000);
+        assertEquals("LatLng should be same", new LatLng(4, 5), mMapboxMap.getCameraPosition().target);
+        assertTrue("Zoomlevel should be same", 10 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    //
+    // Camera - Zoom
+    //
+
+    @Test
+    public void testZoomInMoveCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.moveCamera(CameraUpdateFactory.zoomIn());
+        assertTrue("Zoomlevel should be same", 4 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    @Test
+    public void testZoomOutMoveCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.moveCamera(CameraUpdateFactory.zoomOut());
+        assertTrue("Zoomlevel should be same", 2 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    @Test
+    public void testZoomByMoveCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.moveCamera(CameraUpdateFactory.zoomBy(3));
+        assertTrue("Zoomlevel should be same", 6 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    @Test
+    public void testZoomByPointMoveCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.moveCamera(CameraUpdateFactory.zoomBy(3, new Point(0, 0)));
+        assertTrue("Zoomlevel should be same", 6 == mMapboxMap.getCameraPosition().zoom);
+        // todo calculate and check LatLng
+    }
+
+    @Test
+    public void testZoomToMoveCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.moveCamera(CameraUpdateFactory.zoomTo(12));
+        assertTrue("Zoomlevel should be same", 12 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    @Test
+    public void testZoomInAnimateCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.animateCamera(CameraUpdateFactory.zoomIn());
+        assertTrue("Zoomlevel should be same", 4 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    @Test
+    public void testZoomOutAnimateCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.animateCamera(CameraUpdateFactory.zoomOut());
+        assertTrue("Zoomlevel should be same", 2 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    @Test
+    public void testZoomByAnimateCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.animateCamera(CameraUpdateFactory.zoomBy(3));
+        assertTrue("Zoomlevel should be same", 6 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    @Test
+    public void testZoomToAnimateCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.animateCamera(CameraUpdateFactory.zoomTo(12));
+        assertTrue("Zoomlevel should be same", 12 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    @Test
+    public void testZoomByPointAnimateCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.animateCamera(CameraUpdateFactory.zoomBy(1, new Point(0, 0)));
+        assertTrue("Zoomlevel should be same", 4 == mMapboxMap.getCameraPosition().zoom);
+        // todo calculate and check LatLng
+    }
+
+    @Test
+    public void testZoomInEaseCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.easeCamera(CameraUpdateFactory.zoomIn(), 1000);
+        assertTrue("Zoomlevel should be same", 4 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    @Test
+    public void testZoomOutEaseCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.easeCamera(CameraUpdateFactory.zoomOut(), 1000);
+        assertTrue("Zoomlevel should be same", 2 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    @Test
+    public void testZoomByEaseCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.easeCamera(CameraUpdateFactory.zoomBy(3), 1000);
+        assertTrue("Zoomlevel should be same", 6 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+    @Test
+    public void testZoomByPointCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.easeCamera(CameraUpdateFactory.zoomBy(3, new Point(0, 0)), 1000);
+        assertTrue("Zoomlevel should be same", 6 == mMapboxMap.getCameraPosition().zoom);
+        // todo calculate and check LatLng
+    }
+
+    @Test
+    public void testZoomToEaseCamera() {
+        CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build();
+        mMapboxMap.setCameraPosition(position);
+        mMapboxMap.easeCamera(CameraUpdateFactory.zoomTo(12), 1000);
+        assertTrue("Zoomlevel should be same", 12 == mMapboxMap.getCameraPosition().zoom);
+    }
+
+
+    //
+    // OnMarkerClick interface
+    //
+
     @Test
     public void testOnMarkerClick() {
         mMapboxMap.setOnMarkerClickListener(mOnMarkerClickListener);