diff options
Diffstat (limited to 'platform/android')
15 files changed, 1750 insertions, 19 deletions
diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/FillExtrusionLayer.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/FillExtrusionLayer.java new file mode 100644 index 0000000000..6772da73b1 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/FillExtrusionLayer.java @@ -0,0 +1,339 @@ +// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`. + +package com.mapbox.mapboxsdk.style.layers; + +import android.support.annotation.ColorInt; +import android.support.annotation.NonNull; +import android.support.annotation.UiThread; + +import static com.mapbox.mapboxsdk.utils.ColorUtils.rgbaToColor; + +import com.mapbox.mapboxsdk.style.layers.TransitionOptions; + +/** + * An extruded (3D) polygon. + * + * @see <a href="https://www.mapbox.com/mapbox-gl-style-spec/#layers-fill-extrusion">The online documentation</a> + */ +@UiThread +public class FillExtrusionLayer extends Layer { + + /** + * Creates a FillExtrusionLayer. + * + * @param nativePtr pointer used by core + */ + public FillExtrusionLayer(long nativePtr) { + super(nativePtr); + } + + /** + * Creates a FillExtrusionLayer. + * + * @param layerId the id of the layer + * @param sourceId the id of the source + */ + public FillExtrusionLayer(String layerId, String sourceId) { + initialize(layerId, sourceId); + } + + protected native void initialize(String layerId, String sourceId); + + /** + * Set the source layer. + * + * @param sourceLayer the source layer to set + */ + public void setSourceLayer(String sourceLayer) { + nativeSetSourceLayer(sourceLayer); + } + + /** + * Set the source Layer. + * + * @param sourceLayer the source layer to set + * @return This + */ + public FillExtrusionLayer withSourceLayer(String sourceLayer) { + setSourceLayer(sourceLayer); + return this; + } + + /** + * Get the source layer. + * + * @return sourceLayer the source layer to get + */ + public String getSourceLayer() { + return nativeGetSourceLayer(); + } + + /** + * Set a single filter. + * + * @param filter the filter to set + */ + public void setFilter(Filter.Statement filter) { + nativeSetFilter(filter.toArray()); + } + + /** + * Set a single filter. + * + * @param filter the filter to set + * @return This + */ + public FillExtrusionLayer withFilter(Filter.Statement filter) { + setFilter(filter); + return this; + } + + /** + * Set a property or properties. + * + * @param properties the var-args properties + * @return This + */ + public FillExtrusionLayer withProperties(@NonNull PropertyValue<?>... properties) { + setProperties(properties); + return this; + } + + // Property getters + + /** + * Get the FillExtrusionOpacity property + * + * @return property wrapper value around Float + */ + @SuppressWarnings("unchecked") + public PropertyValue<Float> getFillExtrusionOpacity() { + return (PropertyValue<Float>) new PropertyValue("fill-extrusion-opacity", nativeGetFillExtrusionOpacity()); + } + + /** + * Get the FillExtrusionOpacity property transition options + * + * @return transition options for Float + */ + public TransitionOptions getFillExtrusionOpacityTransition() { + return nativeGetFillExtrusionOpacityTransition(); + } + + /** + * Set the FillExtrusionOpacity property transition options + * + * @param options transition options for Float + */ + public void setFillExtrusionOpacityTransition(TransitionOptions options) { + nativeSetFillExtrusionOpacityTransition(options.getDuration(), options.getDelay()); + } + + /** + * Get the FillExtrusionColor property + * + * @return property wrapper value around String + */ + @SuppressWarnings("unchecked") + public PropertyValue<String> getFillExtrusionColor() { + return (PropertyValue<String>) new PropertyValue("fill-extrusion-color", nativeGetFillExtrusionColor()); + } + + /** + * The base color of the extruded fill. The extrusion's surfaces will be shaded differently based on this color in combination with the root `light` settings. If this color is specified as `rgba` with an alpha component, the alpha component will be ignored; use `fill-extrusion-opacity` to set layer opacity. + * + * @return int representation of a rgba string color + * @throws RuntimeException thrown if property isn't a value + */ + @ColorInt + public int getFillExtrusionColorAsInt() { + PropertyValue<String> value = getFillExtrusionColor(); + if (value.isValue()) { + return rgbaToColor(value.getValue()); + } else { + throw new RuntimeException("fill-extrusion-color was set as a Function"); + } + } + + /** + * Get the FillExtrusionColor property transition options + * + * @return transition options for String + */ + public TransitionOptions getFillExtrusionColorTransition() { + return nativeGetFillExtrusionColorTransition(); + } + + /** + * Set the FillExtrusionColor property transition options + * + * @param options transition options for String + */ + public void setFillExtrusionColorTransition(TransitionOptions options) { + nativeSetFillExtrusionColorTransition(options.getDuration(), options.getDelay()); + } + + /** + * Get the FillExtrusionTranslate property + * + * @return property wrapper value around Float[] + */ + @SuppressWarnings("unchecked") + public PropertyValue<Float[]> getFillExtrusionTranslate() { + return (PropertyValue<Float[]>) new PropertyValue("fill-extrusion-translate", nativeGetFillExtrusionTranslate()); + } + + /** + * Get the FillExtrusionTranslate property transition options + * + * @return transition options for Float[] + */ + public TransitionOptions getFillExtrusionTranslateTransition() { + return nativeGetFillExtrusionTranslateTransition(); + } + + /** + * Set the FillExtrusionTranslate property transition options + * + * @param options transition options for Float[] + */ + public void setFillExtrusionTranslateTransition(TransitionOptions options) { + nativeSetFillExtrusionTranslateTransition(options.getDuration(), options.getDelay()); + } + + /** + * Get the FillExtrusionTranslateAnchor property + * + * @return property wrapper value around String + */ + @SuppressWarnings("unchecked") + public PropertyValue<String> getFillExtrusionTranslateAnchor() { + return (PropertyValue<String>) new PropertyValue("fill-extrusion-translate-anchor", nativeGetFillExtrusionTranslateAnchor()); + } + + /** + * Get the FillExtrusionPattern property + * + * @return property wrapper value around String + */ + @SuppressWarnings("unchecked") + public PropertyValue<String> getFillExtrusionPattern() { + return (PropertyValue<String>) new PropertyValue("fill-extrusion-pattern", nativeGetFillExtrusionPattern()); + } + + /** + * Get the FillExtrusionPattern property transition options + * + * @return transition options for String + */ + public TransitionOptions getFillExtrusionPatternTransition() { + return nativeGetFillExtrusionPatternTransition(); + } + + /** + * Set the FillExtrusionPattern property transition options + * + * @param options transition options for String + */ + public void setFillExtrusionPatternTransition(TransitionOptions options) { + nativeSetFillExtrusionPatternTransition(options.getDuration(), options.getDelay()); + } + + /** + * Get the FillExtrusionHeight property + * + * @return property wrapper value around Float + */ + @SuppressWarnings("unchecked") + public PropertyValue<Float> getFillExtrusionHeight() { + return (PropertyValue<Float>) new PropertyValue("fill-extrusion-height", nativeGetFillExtrusionHeight()); + } + + /** + * Get the FillExtrusionHeight property transition options + * + * @return transition options for Float + */ + public TransitionOptions getFillExtrusionHeightTransition() { + return nativeGetFillExtrusionHeightTransition(); + } + + /** + * Set the FillExtrusionHeight property transition options + * + * @param options transition options for Float + */ + public void setFillExtrusionHeightTransition(TransitionOptions options) { + nativeSetFillExtrusionHeightTransition(options.getDuration(), options.getDelay()); + } + + /** + * Get the FillExtrusionBase property + * + * @return property wrapper value around Float + */ + @SuppressWarnings("unchecked") + public PropertyValue<Float> getFillExtrusionBase() { + return (PropertyValue<Float>) new PropertyValue("fill-extrusion-base", nativeGetFillExtrusionBase()); + } + + /** + * Get the FillExtrusionBase property transition options + * + * @return transition options for Float + */ + public TransitionOptions getFillExtrusionBaseTransition() { + return nativeGetFillExtrusionBaseTransition(); + } + + /** + * Set the FillExtrusionBase property transition options + * + * @param options transition options for Float + */ + public void setFillExtrusionBaseTransition(TransitionOptions options) { + nativeSetFillExtrusionBaseTransition(options.getDuration(), options.getDelay()); + } + + private native Object nativeGetFillExtrusionOpacity(); + + private native TransitionOptions nativeGetFillExtrusionOpacityTransition(); + + private native void nativeSetFillExtrusionOpacityTransition(long duration, long delay); + + private native Object nativeGetFillExtrusionColor(); + + private native TransitionOptions nativeGetFillExtrusionColorTransition(); + + private native void nativeSetFillExtrusionColorTransition(long duration, long delay); + + private native Object nativeGetFillExtrusionTranslate(); + + private native TransitionOptions nativeGetFillExtrusionTranslateTransition(); + + private native void nativeSetFillExtrusionTranslateTransition(long duration, long delay); + + private native Object nativeGetFillExtrusionTranslateAnchor(); + + private native Object nativeGetFillExtrusionPattern(); + + private native TransitionOptions nativeGetFillExtrusionPatternTransition(); + + private native void nativeSetFillExtrusionPatternTransition(long duration, long delay); + + private native Object nativeGetFillExtrusionHeight(); + + private native TransitionOptions nativeGetFillExtrusionHeightTransition(); + + private native void nativeSetFillExtrusionHeightTransition(long duration, long delay); + + private native Object nativeGetFillExtrusionBase(); + + private native TransitionOptions nativeGetFillExtrusionBaseTransition(); + + private native void nativeSetFillExtrusionBaseTransition(long duration, long delay); + + @Override + protected native void finalize() throws Throwable; + +} diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/Property.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/Property.java index 641ee551a2..48e0ec5de3 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/Property.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/Property.java @@ -446,6 +446,27 @@ public final class Property { @Retention(RetentionPolicy.SOURCE) public @interface CIRCLE_PITCH_SCALE {} + // FILL_EXTRUSION_TRANSLATE_ANCHOR: Controls the translation reference point. + + /** + * The fill extrusion is translated relative to the map. + */ + public static final String FILL_EXTRUSION_TRANSLATE_ANCHOR_MAP = "map"; + /** + * The fill extrusion is translated relative to the viewport. + */ + public static final String FILL_EXTRUSION_TRANSLATE_ANCHOR_VIEWPORT = "viewport"; + + /** + * Controls the translation reference point. + */ + @StringDef({ + FILL_EXTRUSION_TRANSLATE_ANCHOR_MAP, + FILL_EXTRUSION_TRANSLATE_ANCHOR_VIEWPORT, + }) + @Retention(RetentionPolicy.SOURCE) + public @interface FILL_EXTRUSION_TRANSLATE_ANCHOR {} + private Property() { } diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/PropertyFactory.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/PropertyFactory.java index e37245000e..e4ea9676fa 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/PropertyFactory.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/PropertyFactory.java @@ -1029,6 +1029,170 @@ public class PropertyFactory { } /** + * The opacity of the entire fill extrusion layer. This is rendered on a per-layer, not per-feature, basis, and data-driven styling is not available. + * + * @param value a Float value + * @return property wrapper around Float + */ + public static PropertyValue<Float> fillExtrusionOpacity(Float value) { + return new PaintPropertyValue<>("fill-extrusion-opacity", value); + } + + + /** + * The opacity of the entire fill extrusion layer. This is rendered on a per-layer, not per-feature, basis, and data-driven styling is not available. + * + * @param <Z> the zoom parameter type + * @param function a wrapper {@link CameraFunction} for Float + * @return property wrapper around a Float function + */ + public static <Z extends Number> PropertyValue<CameraFunction<Z, Float>> fillExtrusionOpacity(CameraFunction<Z, Float> function) { + return new PaintPropertyValue<>("fill-extrusion-opacity", function); + } + + /** + * The base color of the extruded fill. The extrusion's surfaces will be shaded differently based on this color in combination with the root `light` settings. If this color is specified as `rgba` with an alpha component, the alpha component will be ignored; use {@link PropertyFactory#fillExtrusionOpacity} to set layer opacity. + * + * @param value a int color value + * @return property wrapper around String color + */ + public static PropertyValue<String> fillExtrusionColor(@ColorInt int value) { + return new PaintPropertyValue<>("fill-extrusion-color", colorToRgbaString(value)); + } + + /** + * The base color of the extruded fill. The extrusion's surfaces will be shaded differently based on this color in combination with the root `light` settings. If this color is specified as `rgba` with an alpha component, the alpha component will be ignored; use {@link PropertyFactory#fillExtrusionOpacity} to set layer opacity. + * + * @param value a String value + * @return property wrapper around String + */ + public static PropertyValue<String> fillExtrusionColor(String value) { + return new PaintPropertyValue<>("fill-extrusion-color", value); + } + + + /** + * The base color of the extruded fill. The extrusion's surfaces will be shaded differently based on this color in combination with the root `light` settings. If this color is specified as `rgba` with an alpha component, the alpha component will be ignored; use {@link PropertyFactory#fillExtrusionOpacity} to set layer opacity. + * + * @param <T> the function input type + * @param function a wrapper function for String + * @return property wrapper around a String function + */ + public static <T> PropertyValue<Function<T, String>> fillExtrusionColor(Function<T, String> function) { + return new PaintPropertyValue<>("fill-extrusion-color", function); + } + + /** + * The geometry's offset. Values are [x, y] where negatives indicate left and up (on the flat plane), respectively. + * + * @param value a Float[] value + * @return property wrapper around Float[] + */ + public static PropertyValue<Float[]> fillExtrusionTranslate(Float[] value) { + return new PaintPropertyValue<>("fill-extrusion-translate", value); + } + + + /** + * The geometry's offset. Values are [x, y] where negatives indicate left and up (on the flat plane), respectively. + * + * @param <Z> the zoom parameter type + * @param function a wrapper {@link CameraFunction} for Float[] + * @return property wrapper around a Float[] function + */ + public static <Z extends Number> PropertyValue<CameraFunction<Z, Float[]>> fillExtrusionTranslate(CameraFunction<Z, Float[]> function) { + return new PaintPropertyValue<>("fill-extrusion-translate", function); + } + + /** + * Controls the translation reference point. + * + * @param value a String value + * @return property wrapper around String + */ + public static PropertyValue<String> fillExtrusionTranslateAnchor(@Property.FILL_EXTRUSION_TRANSLATE_ANCHOR String value) { + return new PaintPropertyValue<>("fill-extrusion-translate-anchor", value); + } + + + /** + * Controls the translation reference point. + * + * @param <Z> the zoom parameter type + * @param function a wrapper {@link CameraFunction} for String + * @return property wrapper around a String function + */ + public static <Z extends Number> PropertyValue<CameraFunction<Z, String>> fillExtrusionTranslateAnchor(CameraFunction<Z, String> function) { + return new PaintPropertyValue<>("fill-extrusion-translate-anchor", function); + } + + /** + * Name of image in sprite to use for drawing images on extruded fills. For seamless patterns, image width and height must be a factor of two (2, 4, 8, ..., 512). + * + * @param value a String value + * @return property wrapper around String + */ + public static PropertyValue<String> fillExtrusionPattern(String value) { + return new PaintPropertyValue<>("fill-extrusion-pattern", value); + } + + + /** + * Name of image in sprite to use for drawing images on extruded fills. For seamless patterns, image width and height must be a factor of two (2, 4, 8, ..., 512). + * + * @param <Z> the zoom parameter type + * @param function a wrapper {@link CameraFunction} for String + * @return property wrapper around a String function + */ + public static <Z extends Number> PropertyValue<CameraFunction<Z, String>> fillExtrusionPattern(CameraFunction<Z, String> function) { + return new PaintPropertyValue<>("fill-extrusion-pattern", function); + } + + /** + * The height with which to extrude this layer. + * + * @param value a Float value + * @return property wrapper around Float + */ + public static PropertyValue<Float> fillExtrusionHeight(Float value) { + return new PaintPropertyValue<>("fill-extrusion-height", value); + } + + + /** + * The height with which to extrude this layer. + * + * @param <T> the function input type + * @param function a wrapper function for Float + * @return property wrapper around a Float function + */ + public static <T> PropertyValue<Function<T, Float>> fillExtrusionHeight(Function<T, Float> function) { + return new PaintPropertyValue<>("fill-extrusion-height", function); + } + + /** + * The height with which to extrude the base of this layer. Must be less than or equal to {@link PropertyFactory#fillExtrusionHeight}. + * + * @param value a Float value + * @return property wrapper around Float + */ + public static PropertyValue<Float> fillExtrusionBase(Float value) { + return new PaintPropertyValue<>("fill-extrusion-base", value); + } + + + /** + * The height with which to extrude the base of this layer. Must be less than or equal to {@link PropertyFactory#fillExtrusionHeight}. + * + * @param <T> the function input type + * @param function a wrapper function for Float + * @return property wrapper around a Float function + */ + public static <T> PropertyValue<Function<T, Float>> fillExtrusionBase(Function<T, Float> function) { + return new PaintPropertyValue<>("fill-extrusion-base", function); + } + + /** * The opacity at which the image will be drawn. * * @param value a Float value diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/BackgroundLayerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/BackgroundLayerTest.java index 5bab1de904..851660f06e 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/BackgroundLayerTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/BackgroundLayerTest.java @@ -3,33 +3,42 @@ package com.mapbox.mapboxsdk.testapp.style; import android.graphics.Color; +import android.support.test.espresso.Espresso; +import android.support.test.rule.ActivityTestRule; import android.support.test.runner.AndroidJUnit4; +import timber.log.Timber; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.style.functions.CompositeFunction; import com.mapbox.mapboxsdk.style.functions.CameraFunction; +import com.mapbox.mapboxsdk.style.functions.SourceFunction; +import com.mapbox.mapboxsdk.style.functions.stops.CategoricalStops; import com.mapbox.mapboxsdk.style.functions.stops.ExponentialStops; +import com.mapbox.mapboxsdk.style.functions.stops.IdentityStops; import com.mapbox.mapboxsdk.style.functions.stops.IntervalStops; +import com.mapbox.mapboxsdk.style.functions.stops.Stop; +import com.mapbox.mapboxsdk.style.functions.stops.Stops; import com.mapbox.mapboxsdk.style.layers.BackgroundLayer; -import com.mapbox.mapboxsdk.style.layers.TransitionOptions; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity; +import com.mapbox.mapboxsdk.testapp.utils.OnMapReadyIdlingResource; import com.mapbox.mapboxsdk.testapp.activity.BaseActivityTest; -import com.mapbox.mapboxsdk.testapp.activity.espresso.EspressoTestActivity; +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; -import timber.log.Timber; - -import static com.mapbox.mapboxsdk.style.functions.Function.zoom; +import static com.mapbox.mapboxsdk.style.functions.Function.*; import static com.mapbox.mapboxsdk.style.functions.stops.Stop.stop; -import static com.mapbox.mapboxsdk.style.functions.stops.Stops.exponential; -import static com.mapbox.mapboxsdk.style.functions.stops.Stops.interval; -import static com.mapbox.mapboxsdk.style.layers.Property.NONE; -import static com.mapbox.mapboxsdk.style.layers.Property.VISIBLE; -import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.backgroundColor; -import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.backgroundOpacity; -import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.backgroundPattern; -import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.visibility; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; +import static com.mapbox.mapboxsdk.style.functions.stops.Stops.*; +import static org.junit.Assert.*; +import static com.mapbox.mapboxsdk.style.layers.Property.*; +import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*; + +import com.mapbox.mapboxsdk.style.layers.TransitionOptions; +import com.mapbox.mapboxsdk.testapp.activity.espresso.EspressoTestActivity; /** * Basic smoke tests for BackgroundLayer @@ -44,7 +53,7 @@ public class BackgroundLayerTest extends BaseActivityTest { return EspressoTestActivity.class; } - private void setupLayer() { + private void setupLayer(){ Timber.i("Retrieving layer"); layer = mapboxMap.getLayerAs("background"); } diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/FillExtrusionLayerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/FillExtrusionLayerTest.java new file mode 100644 index 0000000000..fec9a6c119 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/FillExtrusionLayerTest.java @@ -0,0 +1,760 @@ +// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`. + +package com.mapbox.mapboxsdk.testapp.style; + +import android.graphics.Color; +import android.support.test.espresso.Espresso; +import android.support.test.rule.ActivityTestRule; +import android.support.test.runner.AndroidJUnit4; +import timber.log.Timber; + +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.style.functions.CompositeFunction; +import com.mapbox.mapboxsdk.style.functions.CameraFunction; +import com.mapbox.mapboxsdk.style.functions.SourceFunction; +import com.mapbox.mapboxsdk.style.functions.stops.CategoricalStops; +import com.mapbox.mapboxsdk.style.functions.stops.ExponentialStops; +import com.mapbox.mapboxsdk.style.functions.stops.IdentityStops; +import com.mapbox.mapboxsdk.style.functions.stops.IntervalStops; +import com.mapbox.mapboxsdk.style.functions.stops.Stop; +import com.mapbox.mapboxsdk.style.functions.stops.Stops; +import com.mapbox.mapboxsdk.style.layers.FillExtrusionLayer; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity; +import com.mapbox.mapboxsdk.testapp.utils.OnMapReadyIdlingResource; +import com.mapbox.mapboxsdk.testapp.activity.BaseActivityTest; + +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import static com.mapbox.mapboxsdk.style.functions.Function.*; +import static com.mapbox.mapboxsdk.style.functions.stops.Stop.stop; +import static com.mapbox.mapboxsdk.style.functions.stops.Stops.*; +import static org.junit.Assert.*; +import static com.mapbox.mapboxsdk.style.layers.Property.*; +import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*; + +import com.mapbox.mapboxsdk.style.layers.TransitionOptions; +import com.mapbox.mapboxsdk.testapp.activity.espresso.EspressoTestActivity; + +/** + * Basic smoke tests for FillExtrusionLayer + */ +@RunWith(AndroidJUnit4.class) +public class FillExtrusionLayerTest extends BaseActivityTest { + + private FillExtrusionLayer layer; + + @Override + protected Class getActivityClass() { + return EspressoTestActivity.class; + } + + private void setupLayer(){ + if ((layer = mapboxMap.getLayerAs("my-layer")) == null) { + Timber.i("Adding layer"); + layer = new FillExtrusionLayer("my-layer", "composite"); + layer.setSourceLayer("composite"); + mapboxMap.addLayer(layer); + // Layer reference is now stale, get new reference + layer = mapboxMap.getLayerAs("my-layer"); + } + } + + @Test + public void testSetVisibility() { + validateTestSetup(); + setupLayer(); + Timber.i("Visibility"); + assertNotNull(layer); + + // Get initial + assertEquals(layer.getVisibility().getValue(), VISIBLE); + + // Set + layer.setProperties(visibility(NONE)); + assertEquals(layer.getVisibility().getValue(), NONE); + } + + @Test + public void testSourceLayer() { + validateTestSetup(); + setupLayer(); + Timber.i("SourceLayer"); + assertNotNull(layer); + + // Get initial + assertEquals(layer.getSourceLayer(), "composite"); + + // Set + final String sourceLayer = "test"; + layer.setSourceLayer(sourceLayer); + assertEquals(layer.getSourceLayer(), sourceLayer); + } + + @Test + public void testFillExtrusionOpacityTransition() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-opacityTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setFillExtrusionOpacityTransition(options); + assertEquals(layer.getFillExtrusionOpacityTransition(), options); + } + + @Test + public void testFillExtrusionOpacityAsConstant() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-opacity"); + assertNotNull(layer); + + // Set and Get + layer.setProperties(fillExtrusionOpacity(0.3f)); + assertEquals((Float) layer.getFillExtrusionOpacity().getValue(), (Float) 0.3f); + } + + @Test + public void testFillExtrusionOpacityAsCameraFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-opacity"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionOpacity( + zoom( + exponential( + stop(2, fillExtrusionOpacity(0.3f)) + ).withBase(0.5f) + ) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionOpacity()); + assertNotNull(layer.getFillExtrusionOpacity().getFunction()); + assertEquals(CameraFunction.class, layer.getFillExtrusionOpacity().getFunction().getClass()); + assertEquals(ExponentialStops.class, layer.getFillExtrusionOpacity().getFunction().getStops().getClass()); + assertEquals(0.5f, ((ExponentialStops) layer.getFillExtrusionOpacity().getFunction().getStops()).getBase(), 0.001); + assertEquals(1, ((ExponentialStops) layer.getFillExtrusionOpacity().getFunction().getStops()).size()); + } + + @Test + public void testFillExtrusionColorTransition() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-colorTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setFillExtrusionColorTransition(options); + assertEquals(layer.getFillExtrusionColorTransition(), options); + } + + @Test + public void testFillExtrusionColorAsConstant() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-color"); + assertNotNull(layer); + + // Set and Get + layer.setProperties(fillExtrusionColor("rgba(0, 0, 0, 1)")); + assertEquals((String) layer.getFillExtrusionColor().getValue(), (String) "rgba(0, 0, 0, 1)"); + } + + @Test + public void testFillExtrusionColorAsCameraFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-color"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionColor( + zoom( + exponential( + stop(2, fillExtrusionColor("rgba(0, 0, 0, 1)")) + ).withBase(0.5f) + ) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionColor()); + assertNotNull(layer.getFillExtrusionColor().getFunction()); + assertEquals(CameraFunction.class, layer.getFillExtrusionColor().getFunction().getClass()); + assertEquals(ExponentialStops.class, layer.getFillExtrusionColor().getFunction().getStops().getClass()); + assertEquals(0.5f, ((ExponentialStops) layer.getFillExtrusionColor().getFunction().getStops()).getBase(), 0.001); + assertEquals(1, ((ExponentialStops) layer.getFillExtrusionColor().getFunction().getStops()).size()); + } + + @Test + public void testFillExtrusionColorAsIdentitySourceFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-color"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionColor(property("FeaturePropertyA", Stops.<String>identity())) + ); + + // Verify + assertNotNull(layer.getFillExtrusionColor()); + assertNotNull(layer.getFillExtrusionColor().getFunction()); + assertEquals(SourceFunction.class, layer.getFillExtrusionColor().getFunction().getClass()); + assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionColor().getFunction()).getProperty()); + assertEquals(IdentityStops.class, layer.getFillExtrusionColor().getFunction().getStops().getClass()); + } + + @Test + public void testFillExtrusionColorAsExponentialSourceFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-color"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionColor( + property( + "FeaturePropertyA", + exponential( + stop(Color.RED, fillExtrusionColor(Color.RED)) + ).withBase(0.5f) + ) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionColor()); + assertNotNull(layer.getFillExtrusionColor().getFunction()); + assertEquals(SourceFunction.class, layer.getFillExtrusionColor().getFunction().getClass()); + assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionColor().getFunction()).getProperty()); + assertEquals(ExponentialStops.class, layer.getFillExtrusionColor().getFunction().getStops().getClass()); + } + + @Test + public void testFillExtrusionColorAsCategoricalSourceFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-color"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionColor( + property( + "FeaturePropertyA", + categorical( + stop("valueA", fillExtrusionColor(Color.RED)) + ) + ).withDefaultValue(fillExtrusionColor(Color.GREEN)) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionColor()); + assertNotNull(layer.getFillExtrusionColor().getFunction()); + assertEquals(SourceFunction.class, layer.getFillExtrusionColor().getFunction().getClass()); + assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionColor().getFunction()).getProperty()); + assertEquals(CategoricalStops.class, layer.getFillExtrusionColor().getFunction().getStops().getClass()); + assertNotNull(((SourceFunction) layer.getFillExtrusionColor().getFunction()).getDefaultValue()); + assertNotNull(((SourceFunction) layer.getFillExtrusionColor().getFunction()).getDefaultValue().getValue()); + assertEquals(Color.GREEN, (int) ((SourceFunction) layer.getFillExtrusionColor().getFunction()).getDefaultValue().getColorInt()); + } + + @Test + public void testFillExtrusionColorAsIntConstant() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-color"); + assertNotNull(layer); + + // Set and Get + layer.setProperties(fillExtrusionColor(Color.RED)); + assertEquals(layer.getFillExtrusionColorAsInt(), Color.RED); + } + + @Test + public void testFillExtrusionTranslateTransition() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-translateTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setFillExtrusionTranslateTransition(options); + assertEquals(layer.getFillExtrusionTranslateTransition(), options); + } + + @Test + public void testFillExtrusionTranslateAsConstant() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-translate"); + assertNotNull(layer); + + // Set and Get + layer.setProperties(fillExtrusionTranslate(new Float[]{0f,0f})); + assertEquals((Float[]) layer.getFillExtrusionTranslate().getValue(), (Float[]) new Float[]{0f,0f}); + } + + @Test + public void testFillExtrusionTranslateAsCameraFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-translate"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionTranslate( + zoom( + exponential( + stop(2, fillExtrusionTranslate(new Float[]{0f,0f})) + ).withBase(0.5f) + ) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionTranslate()); + assertNotNull(layer.getFillExtrusionTranslate().getFunction()); + assertEquals(CameraFunction.class, layer.getFillExtrusionTranslate().getFunction().getClass()); + assertEquals(ExponentialStops.class, layer.getFillExtrusionTranslate().getFunction().getStops().getClass()); + assertEquals(0.5f, ((ExponentialStops) layer.getFillExtrusionTranslate().getFunction().getStops()).getBase(), 0.001); + assertEquals(1, ((ExponentialStops) layer.getFillExtrusionTranslate().getFunction().getStops()).size()); + } + + @Test + public void testFillExtrusionTranslateAnchorAsConstant() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-translate-anchor"); + assertNotNull(layer); + + // Set and Get + layer.setProperties(fillExtrusionTranslateAnchor(FILL_EXTRUSION_TRANSLATE_ANCHOR_MAP)); + assertEquals((String) layer.getFillExtrusionTranslateAnchor().getValue(), (String) FILL_EXTRUSION_TRANSLATE_ANCHOR_MAP); + } + + @Test + public void testFillExtrusionTranslateAnchorAsCameraFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-translate-anchor"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionTranslateAnchor( + zoom( + interval( + stop(2, fillExtrusionTranslateAnchor(FILL_EXTRUSION_TRANSLATE_ANCHOR_MAP)) + ) + ) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionTranslateAnchor()); + assertNotNull(layer.getFillExtrusionTranslateAnchor().getFunction()); + assertEquals(CameraFunction.class, layer.getFillExtrusionTranslateAnchor().getFunction().getClass()); + assertEquals(IntervalStops.class, layer.getFillExtrusionTranslateAnchor().getFunction().getStops().getClass()); + assertEquals(1, ((IntervalStops) layer.getFillExtrusionTranslateAnchor().getFunction().getStops()).size()); + } + + @Test + public void testFillExtrusionPatternTransition() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-patternTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setFillExtrusionPatternTransition(options); + assertEquals(layer.getFillExtrusionPatternTransition(), options); + } + + @Test + public void testFillExtrusionPatternAsConstant() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-pattern"); + assertNotNull(layer); + + // Set and Get + layer.setProperties(fillExtrusionPattern("pedestrian-polygon")); + assertEquals((String) layer.getFillExtrusionPattern().getValue(), (String) "pedestrian-polygon"); + } + + @Test + public void testFillExtrusionPatternAsCameraFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-pattern"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionPattern( + zoom( + interval( + stop(2, fillExtrusionPattern("pedestrian-polygon")) + ) + ) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionPattern()); + assertNotNull(layer.getFillExtrusionPattern().getFunction()); + assertEquals(CameraFunction.class, layer.getFillExtrusionPattern().getFunction().getClass()); + assertEquals(IntervalStops.class, layer.getFillExtrusionPattern().getFunction().getStops().getClass()); + assertEquals(1, ((IntervalStops) layer.getFillExtrusionPattern().getFunction().getStops()).size()); + } + + @Test + public void testFillExtrusionHeightTransition() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-heightTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setFillExtrusionHeightTransition(options); + assertEquals(layer.getFillExtrusionHeightTransition(), options); + } + + @Test + public void testFillExtrusionHeightAsConstant() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-height"); + assertNotNull(layer); + + // Set and Get + layer.setProperties(fillExtrusionHeight(0.3f)); + assertEquals((Float) layer.getFillExtrusionHeight().getValue(), (Float) 0.3f); + } + + @Test + public void testFillExtrusionHeightAsCameraFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-height"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionHeight( + zoom( + exponential( + stop(2, fillExtrusionHeight(0.3f)) + ).withBase(0.5f) + ) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionHeight()); + assertNotNull(layer.getFillExtrusionHeight().getFunction()); + assertEquals(CameraFunction.class, layer.getFillExtrusionHeight().getFunction().getClass()); + assertEquals(ExponentialStops.class, layer.getFillExtrusionHeight().getFunction().getStops().getClass()); + assertEquals(0.5f, ((ExponentialStops) layer.getFillExtrusionHeight().getFunction().getStops()).getBase(), 0.001); + assertEquals(1, ((ExponentialStops) layer.getFillExtrusionHeight().getFunction().getStops()).size()); + } + + @Test + public void testFillExtrusionHeightAsIdentitySourceFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-height"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionHeight(property("FeaturePropertyA", Stops.<Float>identity())) + ); + + // Verify + assertNotNull(layer.getFillExtrusionHeight()); + assertNotNull(layer.getFillExtrusionHeight().getFunction()); + assertEquals(SourceFunction.class, layer.getFillExtrusionHeight().getFunction().getClass()); + assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionHeight().getFunction()).getProperty()); + assertEquals(IdentityStops.class, layer.getFillExtrusionHeight().getFunction().getStops().getClass()); + } + + @Test + public void testFillExtrusionHeightAsExponentialSourceFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-height"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionHeight( + property( + "FeaturePropertyA", + exponential( + stop(0.3f, fillExtrusionHeight(0.3f)) + ).withBase(0.5f) + ) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionHeight()); + assertNotNull(layer.getFillExtrusionHeight().getFunction()); + assertEquals(SourceFunction.class, layer.getFillExtrusionHeight().getFunction().getClass()); + assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionHeight().getFunction()).getProperty()); + assertEquals(ExponentialStops.class, layer.getFillExtrusionHeight().getFunction().getStops().getClass()); + } + + @Test + public void testFillExtrusionHeightAsCategoricalSourceFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-height"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionHeight( + property( + "FeaturePropertyA", + categorical( + stop(1.0f, fillExtrusionHeight(0.3f)) + ) + ).withDefaultValue(fillExtrusionHeight(0.3f)) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionHeight()); + assertNotNull(layer.getFillExtrusionHeight().getFunction()); + assertEquals(SourceFunction.class, layer.getFillExtrusionHeight().getFunction().getClass()); + assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionHeight().getFunction()).getProperty()); + assertEquals(CategoricalStops.class, layer.getFillExtrusionHeight().getFunction().getStops().getClass()); + assertNotNull(((SourceFunction) layer.getFillExtrusionHeight().getFunction()).getDefaultValue()); + assertNotNull(((SourceFunction) layer.getFillExtrusionHeight().getFunction()).getDefaultValue().getValue()); + assertEquals(0.3f, ((SourceFunction) layer.getFillExtrusionHeight().getFunction()).getDefaultValue().getValue()); + } + + @Test + public void testFillExtrusionHeightAsCompositeFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-height"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionHeight( + composite( + "FeaturePropertyA", + exponential( + stop(0, 0.3f, fillExtrusionHeight(0.9f)) + ).withBase(0.5f) + ).withDefaultValue(fillExtrusionHeight(0.3f)) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionHeight()); + assertNotNull(layer.getFillExtrusionHeight().getFunction()); + assertEquals(CompositeFunction.class, layer.getFillExtrusionHeight().getFunction().getClass()); + assertEquals("FeaturePropertyA", ((CompositeFunction) layer.getFillExtrusionHeight().getFunction()).getProperty()); + assertEquals(ExponentialStops.class, layer.getFillExtrusionHeight().getFunction().getStops().getClass()); + assertEquals(1, ((ExponentialStops) layer.getFillExtrusionHeight().getFunction().getStops()).size()); + + ExponentialStops<Stop.CompositeValue<Float, Float>, Float> stops = + (ExponentialStops<Stop.CompositeValue<Float, Float>, Float>) layer.getFillExtrusionHeight().getFunction().getStops(); + Stop<Stop.CompositeValue<Float, Float>, Float> stop = stops.iterator().next(); + assertEquals(0f, stop.in.zoom, 0.001); + assertEquals(0.3f, stop.in.value, 0.001f); + assertEquals(0.9f, stop.out, 0.001f); + } + + @Test + public void testFillExtrusionBaseTransition() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-baseTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setFillExtrusionBaseTransition(options); + assertEquals(layer.getFillExtrusionBaseTransition(), options); + } + + @Test + public void testFillExtrusionBaseAsConstant() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-base"); + assertNotNull(layer); + + // Set and Get + layer.setProperties(fillExtrusionBase(0.3f)); + assertEquals((Float) layer.getFillExtrusionBase().getValue(), (Float) 0.3f); + } + + @Test + public void testFillExtrusionBaseAsCameraFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-base"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionBase( + zoom( + exponential( + stop(2, fillExtrusionBase(0.3f)) + ).withBase(0.5f) + ) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionBase()); + assertNotNull(layer.getFillExtrusionBase().getFunction()); + assertEquals(CameraFunction.class, layer.getFillExtrusionBase().getFunction().getClass()); + assertEquals(ExponentialStops.class, layer.getFillExtrusionBase().getFunction().getStops().getClass()); + assertEquals(0.5f, ((ExponentialStops) layer.getFillExtrusionBase().getFunction().getStops()).getBase(), 0.001); + assertEquals(1, ((ExponentialStops) layer.getFillExtrusionBase().getFunction().getStops()).size()); + } + + @Test + public void testFillExtrusionBaseAsIdentitySourceFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-base"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionBase(property("FeaturePropertyA", Stops.<Float>identity())) + ); + + // Verify + assertNotNull(layer.getFillExtrusionBase()); + assertNotNull(layer.getFillExtrusionBase().getFunction()); + assertEquals(SourceFunction.class, layer.getFillExtrusionBase().getFunction().getClass()); + assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionBase().getFunction()).getProperty()); + assertEquals(IdentityStops.class, layer.getFillExtrusionBase().getFunction().getStops().getClass()); + } + + @Test + public void testFillExtrusionBaseAsExponentialSourceFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-base"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionBase( + property( + "FeaturePropertyA", + exponential( + stop(0.3f, fillExtrusionBase(0.3f)) + ).withBase(0.5f) + ) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionBase()); + assertNotNull(layer.getFillExtrusionBase().getFunction()); + assertEquals(SourceFunction.class, layer.getFillExtrusionBase().getFunction().getClass()); + assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionBase().getFunction()).getProperty()); + assertEquals(ExponentialStops.class, layer.getFillExtrusionBase().getFunction().getStops().getClass()); + } + + @Test + public void testFillExtrusionBaseAsCategoricalSourceFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-base"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionBase( + property( + "FeaturePropertyA", + categorical( + stop(1.0f, fillExtrusionBase(0.3f)) + ) + ).withDefaultValue(fillExtrusionBase(0.3f)) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionBase()); + assertNotNull(layer.getFillExtrusionBase().getFunction()); + assertEquals(SourceFunction.class, layer.getFillExtrusionBase().getFunction().getClass()); + assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionBase().getFunction()).getProperty()); + assertEquals(CategoricalStops.class, layer.getFillExtrusionBase().getFunction().getStops().getClass()); + assertNotNull(((SourceFunction) layer.getFillExtrusionBase().getFunction()).getDefaultValue()); + assertNotNull(((SourceFunction) layer.getFillExtrusionBase().getFunction()).getDefaultValue().getValue()); + assertEquals(0.3f, ((SourceFunction) layer.getFillExtrusionBase().getFunction()).getDefaultValue().getValue()); + } + + @Test + public void testFillExtrusionBaseAsCompositeFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("fill-extrusion-base"); + assertNotNull(layer); + + // Set + layer.setProperties( + fillExtrusionBase( + composite( + "FeaturePropertyA", + exponential( + stop(0, 0.3f, fillExtrusionBase(0.9f)) + ).withBase(0.5f) + ).withDefaultValue(fillExtrusionBase(0.3f)) + ) + ); + + // Verify + assertNotNull(layer.getFillExtrusionBase()); + assertNotNull(layer.getFillExtrusionBase().getFunction()); + assertEquals(CompositeFunction.class, layer.getFillExtrusionBase().getFunction().getClass()); + assertEquals("FeaturePropertyA", ((CompositeFunction) layer.getFillExtrusionBase().getFunction()).getProperty()); + assertEquals(ExponentialStops.class, layer.getFillExtrusionBase().getFunction().getStops().getClass()); + assertEquals(1, ((ExponentialStops) layer.getFillExtrusionBase().getFunction().getStops()).size()); + + ExponentialStops<Stop.CompositeValue<Float, Float>, Float> stops = + (ExponentialStops<Stop.CompositeValue<Float, Float>, Float>) layer.getFillExtrusionBase().getFunction().getStops(); + Stop<Stop.CompositeValue<Float, Float>, Float> stop = stops.iterator().next(); + assertEquals(0f, stop.in.zoom, 0.001); + assertEquals(0.3f, stop.in.value, 0.001f); + assertEquals(0.9f, stop.out, 0.001f); + } + +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/AndroidManifest.xml b/platform/android/MapboxGLAndroidSDKTestApp/src/main/AndroidManifest.xml index 2d2a262055..fc10a01356 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/main/AndroidManifest.xml +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/AndroidManifest.xml @@ -448,6 +448,17 @@ android:value=".activity.FeatureOverviewActivity"/> </activity> <activity + android:name=".activity.style.FillExtrusionActivity" + android:description="@string/description_fill_extrusion_layer" + android:label="@string/activity_fill_extrusion_layer"> + <meta-data + android:name="@string/category" + android:value="@string/category_style"/> + <meta-data + android:name="android.support.PARENT_ACTIVITY" + android:value=".activity.FeatureOverviewActivity"/> + </activity> + <activity android:name=".activity.style.SymbolLayerActivity" android:description="@string/description_symbol_layer" android:label="@string/activity_symbol_layer"> diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/FillExtrusionActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/FillExtrusionActivity.java new file mode 100644 index 0000000000..9a7790c6e5 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/FillExtrusionActivity.java @@ -0,0 +1,135 @@ +package com.mapbox.mapboxsdk.testapp.activity.style; + +import android.graphics.Color; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.AppCompatActivity; + +import com.mapbox.mapboxsdk.camera.CameraPosition; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.style.layers.FillExtrusionLayer; +import com.mapbox.mapboxsdk.style.sources.GeoJsonSource; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.services.commons.geojson.Polygon; + +import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.fillExtrusionColor; +import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.fillExtrusionHeight; +import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.fillExtrusionOpacity; + +/** + * Test activity showcasing fill extrusions + */ +public class FillExtrusionActivity extends AppCompatActivity { + + private MapView mapView; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_fill_extrusion_layer); + + mapView = (MapView) findViewById(R.id.mapView); + mapView.onCreate(savedInstanceState); + mapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull + final MapboxMap map) { + Polygon domTower = Polygon.fromCoordinates(new double[][][] { + new double[][] { + new double[] { + 5.12112557888031, + 52.09071040847704 + }, + new double[] { + 5.121227502822875, + 52.09053901776669 + }, + new double[] { + 5.121484994888306, + 52.090601641371805 + }, + new double[] { + 5.1213884353637695, + 52.090766439912635 + }, + new double[] { + 5.12112557888031, + 52.09071040847704 + } + } + }); + + GeoJsonSource source = new GeoJsonSource("extrusion-source", domTower); + map.addSource(source); + + map.addLayer( + new FillExtrusionLayer("extrusion-layer", source.getId()) + .withProperties( + fillExtrusionHeight(40f), + fillExtrusionOpacity(0.5f), + fillExtrusionColor(Color.RED) + ) + ); + + map.animateCamera( + CameraUpdateFactory.newCameraPosition( + new CameraPosition.Builder() + .target(new LatLng(52.09071040847704, 5.12112557888031)) + .tilt(45.0) + .zoom(18) + .build() + ), + 10000 + ); + } + }); + } + + + @Override + protected void onStart() { + super.onStart(); + mapView.onStart(); + } + + @Override + protected void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + protected void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + protected void onStop() { + super.onStop(); + mapView.onStop(); + } + + @Override + public void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mapView.onSaveInstanceState(outState); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mapView.onLowMemory(); + } + + @Override + public void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/layout/activity_fill_extrusion_layer.xml b/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/layout/activity_fill_extrusion_layer.xml new file mode 100644 index 0000000000..304841dc69 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/layout/activity_fill_extrusion_layer.xml @@ -0,0 +1,17 @@ +<?xml version="1.0" encoding="utf-8"?> +<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" + xmlns:app="http://schemas.android.com/apk/res-auto" + android:layout_width="match_parent" + android:layout_height="match_parent" + android:orientation="vertical"> + + <com.mapbox.mapboxsdk.maps.MapView + android:id="@id/mapView" + android:layout_width="match_parent" + android:layout_height="match_parent" + app:mapbox_cameraTargetLat="52.090710" + app:mapbox_cameraTargetLng="5.121125" + app:mapbox_cameraZoom="10" + app:mapbox_styleUrl="@string/mapbox_style_mapbox_streets"/> + +</RelativeLayout> diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/values/strings.xml b/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/values/strings.xml index 3df14caf0c..6270eac72d 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/values/strings.xml +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/values/strings.xml @@ -57,6 +57,7 @@ <string name="activity_marker_view_rectangle">Marker views in rectangle</string> <string name="activity_url_transform">Url transform</string> <string name="activity_restricted_bounds">Restrict camera to a bounds</string> + <string name="activity_fill_extrusion_layer">Fill extrusions</string> <!--Description--> <string name="description_user_location_tracking">Tracks the location of the user</string> @@ -113,6 +114,7 @@ <string name="description_circle_layer">Show bus stops and route in Singapore</string> <string name="description_url_transform">Transform urls on the fly</string> <string name="description_restricted_bounds">Limit viewport to Iceland</string> + <string name="description_fill_extrusion_layer">Shows how to add 3D extruded shapes</string> <!--Categories--> <string name="category">category</string> diff --git a/platform/android/config.cmake b/platform/android/config.cmake index 7c10ba96f8..c111744ed0 100644 --- a/platform/android/config.cmake +++ b/platform/android/config.cmake @@ -130,6 +130,8 @@ add_library(mbgl-android STATIC platform/android/src/style/layers/circle_layer.hpp platform/android/src/style/layers/custom_layer.cpp platform/android/src/style/layers/custom_layer.hpp + platform/android/src/style/layers/fill_extrusion_layer.cpp + platform/android/src/style/layers/fill_extrusion_layer.hpp platform/android/src/style/layers/fill_layer.cpp platform/android/src/style/layers/fill_layer.hpp platform/android/src/style/layers/layer.cpp diff --git a/platform/android/scripts/generate-style-code.js b/platform/android/scripts/generate-style-code.js index 09563f3b9d..5d8fc4cc6d 100644 --- a/platform/android/scripts/generate-style-code.js +++ b/platform/android/scripts/generate-style-code.js @@ -34,9 +34,6 @@ var layers = Object.keys(spec.layer.type.values).map((type) => { }; }); -// XXX Remove fill-extrusion layer for now -layers = _(layers).filter(layer => layer.type != "fill-extrusion").value(); - // Process all layer properties const layoutProperties = _(layers).map('layoutProperties').flatten().value(); const paintProperties = _(layers).map('paintProperties').flatten().value(); diff --git a/platform/android/src/style/layers/fill_extrusion_layer.cpp b/platform/android/src/style/layers/fill_extrusion_layer.cpp new file mode 100644 index 0000000000..492e1729b9 --- /dev/null +++ b/platform/android/src/style/layers/fill_extrusion_layer.cpp @@ -0,0 +1,200 @@ +// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`. + +#include "fill_extrusion_layer.hpp" + +#include <string> + +#include "../conversion/property_value.hpp" +#include "../conversion/transition_options.hpp" + +namespace mbgl { +namespace android { + + /** + * Creates an owning peer object (for layers not attached to the map) from the JVM side + */ + FillExtrusionLayer::FillExtrusionLayer(jni::JNIEnv& env, jni::String layerId, jni::String sourceId) + : Layer(env, std::make_unique<mbgl::style::FillExtrusionLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) { + } + + /** + * Creates a non-owning peer object (for layers currently attached to the map) + */ + FillExtrusionLayer::FillExtrusionLayer(mbgl::Map& map, mbgl::style::FillExtrusionLayer& coreLayer) + : Layer(map, coreLayer) { + } + + /** + * Creates an owning peer object (for layers not attached to the map) + */ + FillExtrusionLayer::FillExtrusionLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::FillExtrusionLayer> coreLayer) + : Layer(map, std::move(coreLayer)) { + } + + FillExtrusionLayer::~FillExtrusionLayer() = default; + + // Property getters + + jni::Object<jni::ObjectTag> FillExtrusionLayer::getFillExtrusionOpacity(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::getFillExtrusionOpacity()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<TransitionOptions> FillExtrusionLayer::getFillExtrusionOpacityTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::getFillExtrusionOpacityTransition(); + return *convert<jni::Object<TransitionOptions>>(env, options); + } + + void FillExtrusionLayer::setFillExtrusionOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::setFillExtrusionOpacityTransition(options); + } + + jni::Object<jni::ObjectTag> FillExtrusionLayer::getFillExtrusionColor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::getFillExtrusionColor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<TransitionOptions> FillExtrusionLayer::getFillExtrusionColorTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::getFillExtrusionColorTransition(); + return *convert<jni::Object<TransitionOptions>>(env, options); + } + + void FillExtrusionLayer::setFillExtrusionColorTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::setFillExtrusionColorTransition(options); + } + + jni::Object<jni::ObjectTag> FillExtrusionLayer::getFillExtrusionTranslate(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::getFillExtrusionTranslate()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<TransitionOptions> FillExtrusionLayer::getFillExtrusionTranslateTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::getFillExtrusionTranslateTransition(); + return *convert<jni::Object<TransitionOptions>>(env, options); + } + + void FillExtrusionLayer::setFillExtrusionTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::setFillExtrusionTranslateTransition(options); + } + + jni::Object<jni::ObjectTag> FillExtrusionLayer::getFillExtrusionTranslateAnchor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::getFillExtrusionTranslateAnchor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> FillExtrusionLayer::getFillExtrusionPattern(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::getFillExtrusionPattern()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<TransitionOptions> FillExtrusionLayer::getFillExtrusionPatternTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::getFillExtrusionPatternTransition(); + return *convert<jni::Object<TransitionOptions>>(env, options); + } + + void FillExtrusionLayer::setFillExtrusionPatternTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::setFillExtrusionPatternTransition(options); + } + + jni::Object<jni::ObjectTag> FillExtrusionLayer::getFillExtrusionHeight(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::getFillExtrusionHeight()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<TransitionOptions> FillExtrusionLayer::getFillExtrusionHeightTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::getFillExtrusionHeightTransition(); + return *convert<jni::Object<TransitionOptions>>(env, options); + } + + void FillExtrusionLayer::setFillExtrusionHeightTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::setFillExtrusionHeightTransition(options); + } + + jni::Object<jni::ObjectTag> FillExtrusionLayer::getFillExtrusionBase(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::getFillExtrusionBase()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<TransitionOptions> FillExtrusionLayer::getFillExtrusionBaseTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::getFillExtrusionBaseTransition(); + return *convert<jni::Object<TransitionOptions>>(env, options); + } + + void FillExtrusionLayer::setFillExtrusionBaseTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as<mbgl::style::FillExtrusionLayer>()->FillExtrusionLayer::setFillExtrusionBaseTransition(options); + } + + + jni::Class<FillExtrusionLayer> FillExtrusionLayer::javaClass; + + jni::jobject* FillExtrusionLayer::createJavaPeer(jni::JNIEnv& env) { + static auto constructor = FillExtrusionLayer::javaClass.template GetConstructor<jni::jlong>(env); + return FillExtrusionLayer::javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this)); + } + + void FillExtrusionLayer::registerNative(jni::JNIEnv& env) { + // Lookup the class + FillExtrusionLayer::javaClass = *jni::Class<FillExtrusionLayer>::Find(env).NewGlobalRef(env).release(); + + #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name) + + // Register the peer + jni::RegisterNativePeer<FillExtrusionLayer>( + env, FillExtrusionLayer::javaClass, "nativePtr", + std::make_unique<FillExtrusionLayer, JNIEnv&, jni::String, jni::String>, + "initialize", + "finalize", + METHOD(&FillExtrusionLayer::getFillExtrusionOpacityTransition, "nativeGetFillExtrusionOpacityTransition"), + METHOD(&FillExtrusionLayer::setFillExtrusionOpacityTransition, "nativeSetFillExtrusionOpacityTransition"), + METHOD(&FillExtrusionLayer::getFillExtrusionOpacity, "nativeGetFillExtrusionOpacity"), + METHOD(&FillExtrusionLayer::getFillExtrusionColorTransition, "nativeGetFillExtrusionColorTransition"), + METHOD(&FillExtrusionLayer::setFillExtrusionColorTransition, "nativeSetFillExtrusionColorTransition"), + METHOD(&FillExtrusionLayer::getFillExtrusionColor, "nativeGetFillExtrusionColor"), + METHOD(&FillExtrusionLayer::getFillExtrusionTranslateTransition, "nativeGetFillExtrusionTranslateTransition"), + METHOD(&FillExtrusionLayer::setFillExtrusionTranslateTransition, "nativeSetFillExtrusionTranslateTransition"), + METHOD(&FillExtrusionLayer::getFillExtrusionTranslate, "nativeGetFillExtrusionTranslate"), + METHOD(&FillExtrusionLayer::getFillExtrusionTranslateAnchor, "nativeGetFillExtrusionTranslateAnchor"), + METHOD(&FillExtrusionLayer::getFillExtrusionPatternTransition, "nativeGetFillExtrusionPatternTransition"), + METHOD(&FillExtrusionLayer::setFillExtrusionPatternTransition, "nativeSetFillExtrusionPatternTransition"), + METHOD(&FillExtrusionLayer::getFillExtrusionPattern, "nativeGetFillExtrusionPattern"), + METHOD(&FillExtrusionLayer::getFillExtrusionHeightTransition, "nativeGetFillExtrusionHeightTransition"), + METHOD(&FillExtrusionLayer::setFillExtrusionHeightTransition, "nativeSetFillExtrusionHeightTransition"), + METHOD(&FillExtrusionLayer::getFillExtrusionHeight, "nativeGetFillExtrusionHeight"), + METHOD(&FillExtrusionLayer::getFillExtrusionBaseTransition, "nativeGetFillExtrusionBaseTransition"), + METHOD(&FillExtrusionLayer::setFillExtrusionBaseTransition, "nativeSetFillExtrusionBaseTransition"), + METHOD(&FillExtrusionLayer::getFillExtrusionBase, "nativeGetFillExtrusionBase")); + } + +} // namespace android +} // namespace mbgl diff --git a/platform/android/src/style/layers/fill_extrusion_layer.hpp b/platform/android/src/style/layers/fill_extrusion_layer.hpp new file mode 100644 index 0000000000..11a74bc8ef --- /dev/null +++ b/platform/android/src/style/layers/fill_extrusion_layer.hpp @@ -0,0 +1,62 @@ +// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`. + +#pragma once + +#include "layer.hpp" +#include "../transition_options.hpp" +#include <mbgl/style/layers/fill_extrusion_layer.hpp> +#include <jni/jni.hpp> + +namespace mbgl { +namespace android { + +class FillExtrusionLayer : public Layer { +public: + + static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/FillExtrusionLayer"; }; + + static jni::Class<FillExtrusionLayer> javaClass; + + static void registerNative(jni::JNIEnv&); + + FillExtrusionLayer(jni::JNIEnv&, jni::String, jni::String); + + FillExtrusionLayer(mbgl::Map&, mbgl::style::FillExtrusionLayer&); + + FillExtrusionLayer(mbgl::Map&, std::unique_ptr<mbgl::style::FillExtrusionLayer>); + + ~FillExtrusionLayer(); + + // Properties + + jni::Object<jni::ObjectTag> getFillExtrusionOpacity(jni::JNIEnv&); + void setFillExtrusionOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object<TransitionOptions> getFillExtrusionOpacityTransition(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getFillExtrusionColor(jni::JNIEnv&); + void setFillExtrusionColorTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object<TransitionOptions> getFillExtrusionColorTransition(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getFillExtrusionTranslate(jni::JNIEnv&); + void setFillExtrusionTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object<TransitionOptions> getFillExtrusionTranslateTransition(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getFillExtrusionTranslateAnchor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getFillExtrusionPattern(jni::JNIEnv&); + void setFillExtrusionPatternTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object<TransitionOptions> getFillExtrusionPatternTransition(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getFillExtrusionHeight(jni::JNIEnv&); + void setFillExtrusionHeightTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object<TransitionOptions> getFillExtrusionHeightTransition(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getFillExtrusionBase(jni::JNIEnv&); + void setFillExtrusionBaseTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object<TransitionOptions> getFillExtrusionBaseTransition(jni::JNIEnv&); + jni::jobject* createJavaPeer(jni::JNIEnv&); + +}; // class FillExtrusionLayer + +} // namespace android +} // namespace mbgl diff --git a/platform/android/src/style/layers/layer.cpp b/platform/android/src/style/layers/layer.cpp index 58c0c5ee84..1ebad19a87 100644 --- a/platform/android/src/style/layers/layer.cpp +++ b/platform/android/src/style/layers/layer.cpp @@ -139,6 +139,8 @@ namespace android { layer.as<SymbolLayer>()->setSourceLayer(layerId); } else if (layer.is<CircleLayer>()) { layer.as<CircleLayer>()->setSourceLayer(layerId); + } else if(layer.is<FillExtrusionLayer>()) { + layer.as<FillExtrusionLayer>()->setSourceLayer(layerId); } else { mbgl::Log::Warning(mbgl::Event::JNI, "Layer doesn't support source layer"); } @@ -156,6 +158,8 @@ namespace android { sourceLayerId = layer.as<SymbolLayer>()->getSourceLayer(); } else if (layer.is<CircleLayer>()) { sourceLayerId = layer.as<CircleLayer>()->getSourceLayer(); + } else if (layer.is<FillExtrusionLayer>()) { + sourceLayerId = layer.as<FillExtrusionLayer>()->getSourceLayer(); } else { mbgl::Log::Warning(mbgl::Event::JNI, "Layer doesn't support source layer"); } diff --git a/platform/android/src/style/layers/layers.cpp b/platform/android/src/style/layers/layers.cpp index 5c6ee1ae8f..5c49f875ee 100644 --- a/platform/android/src/style/layers/layers.cpp +++ b/platform/android/src/style/layers/layers.cpp @@ -3,6 +3,7 @@ #include <mbgl/style/layer.hpp> #include <mbgl/style/layers/background_layer.hpp> #include <mbgl/style/layers/circle_layer.hpp> +#include <mbgl/style/layers/fill_extrusion_layer.hpp> #include <mbgl/style/layers/fill_layer.hpp> #include <mbgl/style/layers/line_layer.hpp> #include <mbgl/style/layers/raster_layer.hpp> @@ -12,11 +13,13 @@ #include "background_layer.hpp" #include "circle_layer.hpp" #include "custom_layer.hpp" +#include "fill_extrusion_layer.hpp" #include "fill_layer.hpp" #include "line_layer.hpp" #include "raster_layer.hpp" #include "symbol_layer.hpp" #include "unknown_layer.hpp" +#include "fill_extrusion_layer.hpp" namespace mbgl { namespace android { @@ -26,6 +29,8 @@ static Layer* initializeLayerPeer(mbgl::Map& map, mbgl::style::Layer& coreLayer) return new BackgroundLayer(map, *coreLayer.as<mbgl::style::BackgroundLayer>()); } else if (coreLayer.is<mbgl::style::CircleLayer>()) { return new CircleLayer(map, *coreLayer.as<mbgl::style::CircleLayer>()); + } else if (coreLayer.is<mbgl::style::FillExtrusionLayer>()) { + return new FillExtrusionLayer(map, *coreLayer.as<mbgl::style::FillExtrusionLayer>()); } else if (coreLayer.is<mbgl::style::FillLayer>()) { return new FillLayer(map, *coreLayer.as<mbgl::style::FillLayer>()); } else if (coreLayer.is<mbgl::style::LineLayer>()) { @@ -51,6 +56,8 @@ static Layer* initializeLayerPeer(Map& map, std::unique_ptr<mbgl::style::Layer> return createPeer<style::BackgroundLayer, BackgroundLayer>(map, std::move(coreLayer)); } else if (coreLayer->is<style::CircleLayer>()) { return createPeer<style::CircleLayer, CircleLayer>(map, std::move(coreLayer)); + } else if (coreLayer->is<style::FillExtrusionLayer>()) { + return createPeer<style::FillExtrusionLayer, FillExtrusionLayer>(map, std::move(coreLayer)); } else if (coreLayer->is<style::FillLayer>()) { return createPeer<style::FillLayer, FillLayer>(map, std::move(coreLayer)); } else if (coreLayer->is<style::LineLayer>()) { @@ -85,6 +92,7 @@ void registerNativeLayers(jni::JNIEnv& env) { BackgroundLayer::registerNative(env); CircleLayer::registerNative(env); CustomLayer::registerNative(env); + FillExtrusionLayer::registerNative(env); FillLayer::registerNative(env); LineLayer::registerNative(env); RasterLayer::registerNative(env); |