From 939526bac4aff734be4e6382b64c43214eb0bc9b Mon Sep 17 00:00:00 2001 From: Tobrun Date: Fri, 31 Mar 2017 17:51:26 +0200 Subject: [android] - transition options for layer properties (#8509) [android] fixup highlevel bindings for transition options finish integration --- platform/android/CHANGELOG.md | 1 + .../mapboxsdk/style/layers/BackgroundLayer.java | 66 ++++++ .../mapbox/mapboxsdk/style/layers/CircleLayer.java | 175 ++++++++++++++ .../mapbox/mapboxsdk/style/layers/FillLayer.java | 109 +++++++++ .../mapbox/mapboxsdk/style/layers/LineLayer.java | 198 ++++++++++++++++ .../mapbox/mapboxsdk/style/layers/RasterLayer.java | 155 ++++++++++++ .../mapbox/mapboxsdk/style/layers/SymbolLayer.java | 263 ++++++++++++++++++++- .../mapboxsdk/style/layers/TransitionOptions.java | 56 +++++ .../mapbox/mapboxsdk/style/layers/layer.java.ejs | 32 ++- .../testapp/style/BackgroundLayerTest.java | 38 +++ .../mapboxsdk/testapp/style/CircleLayerTest.java | 100 ++++++++ .../mapboxsdk/testapp/style/FillLayerTest.java | 64 +++++ .../mapboxsdk/testapp/style/LineLayerTest.java | 115 +++++++++ .../mapboxsdk/testapp/style/RasterLayerTest.java | 86 +++++++ .../mapboxsdk/testapp/style/SymbolLayerTest.java | 182 ++++++++++++++ .../mapbox/mapboxsdk/testapp/style/layer.junit.ejs | 16 ++ .../activity/style/RuntimeStyleActivity.java | 12 +- platform/android/config.cmake | 2 + platform/android/src/jni.cpp | 2 + .../src/style/conversion/transition_options.hpp | 29 +++ .../android/src/style/layers/background_layer.cpp | 47 ++++ .../android/src/style/layers/background_layer.hpp | 11 +- platform/android/src/style/layers/circle_layer.cpp | 122 ++++++++++ platform/android/src/style/layers/circle_layer.hpp | 21 +- platform/android/src/style/layers/fill_layer.cpp | 77 ++++++ platform/android/src/style/layers/fill_layer.hpp | 15 +- platform/android/src/style/layers/layer.cpp | 1 + platform/android/src/style/layers/layer.cpp.ejs | 24 +- platform/android/src/style/layers/layer.hpp.ejs | 10 +- platform/android/src/style/layers/line_layer.cpp | 137 +++++++++++ platform/android/src/style/layers/line_layer.hpp | 23 +- platform/android/src/style/layers/raster_layer.cpp | 107 +++++++++ platform/android/src/style/layers/raster_layer.hpp | 19 +- platform/android/src/style/layers/symbol_layer.cpp | 182 ++++++++++++++ platform/android/src/style/layers/symbol_layer.hpp | 29 ++- platform/android/src/style/transition_options.cpp | 20 ++ platform/android/src/style/transition_options.hpp | 25 ++ 37 files changed, 2547 insertions(+), 24 deletions(-) create mode 100644 platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/TransitionOptions.java create mode 100644 platform/android/src/style/conversion/transition_options.hpp create mode 100644 platform/android/src/style/transition_options.cpp create mode 100644 platform/android/src/style/transition_options.hpp (limited to 'platform/android') diff --git a/platform/android/CHANGELOG.md b/platform/android/CHANGELOG.md index e194024b40..6bb0d925c8 100644 --- a/platform/android/CHANGELOG.md +++ b/platform/android/CHANGELOG.md @@ -6,6 +6,7 @@ Mapbox welcomes participation and contributions from everyone. If you'd like to 5.1.0 builds further on 5.0.1 and adds: +* Transition Properties for Layer attributes [#8509](https://github.com/mapbox/mapbox-gl-native/pull/8509) * Style wide transition duration and transition offset in milliseconds [#8576](https://github.com/mapbox/mapbox-gl-native/pull/8576) * Transifex integration, Catalan & Dutch translations [#8556](https://github.com/mapbox/mapbox-gl-native/pull/8556) * LatLngBounds includes with another bounds [#8517](https://github.com/mapbox/mapbox-gl-native/pull/8517) diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/BackgroundLayer.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/BackgroundLayer.java index 0f1265f1a1..978fa29ef8 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/BackgroundLayer.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/BackgroundLayer.java @@ -8,6 +8,8 @@ import android.support.annotation.UiThread; import static com.mapbox.mapboxsdk.utils.ColorUtils.rgbaToColor; +import com.mapbox.mapboxsdk.style.layers.TransitionOptions; + /** * The background color or pattern of the map. * @@ -75,6 +77,23 @@ public class BackgroundLayer extends Layer { } } + /** + * Get the BackgroundColor property transition options + * + * @return transition options for String + */ + public TransitionOptions getBackgroundColorTransition() { + return nativeGetBackgroundColorTransition(); + } + + /** + * Set the BackgroundColor property transition options + * + * @param options transition options for String + */ + public void setBackgroundColorTransition(TransitionOptions options) { + nativeSetBackgroundColorTransition(options.getDuration(), options.getDelay()); + } /** * Get the BackgroundPattern property @@ -86,6 +105,24 @@ public class BackgroundLayer extends Layer { return (PropertyValue) new PropertyValue("background-pattern", nativeGetBackgroundPattern()); } + /** + * Get the BackgroundPattern property transition options + * + * @return transition options for String + */ + public TransitionOptions getBackgroundPatternTransition() { + return nativeGetBackgroundPatternTransition(); + } + + /** + * Set the BackgroundPattern property transition options + * + * @param options transition options for String + */ + public void setBackgroundPatternTransition(TransitionOptions options) { + nativeSetBackgroundPatternTransition(options.getDuration(), options.getDelay()); + } + /** * Get the BackgroundOpacity property * @@ -96,12 +133,41 @@ public class BackgroundLayer extends Layer { return (PropertyValue) new PropertyValue("background-opacity", nativeGetBackgroundOpacity()); } + /** + * Get the BackgroundOpacity property transition options + * + * @return transition options for Float + */ + public TransitionOptions getBackgroundOpacityTransition() { + return nativeGetBackgroundOpacityTransition(); + } + + /** + * Set the BackgroundOpacity property transition options + * + * @param options transition options for Float + */ + public void setBackgroundOpacityTransition(TransitionOptions options) { + nativeSetBackgroundOpacityTransition(options.getDuration(), options.getDelay()); + } + private native Object nativeGetBackgroundColor(); + private native TransitionOptions nativeGetBackgroundColorTransition(); + + private native void nativeSetBackgroundColorTransition(long duration, long delay); + private native Object nativeGetBackgroundPattern(); + private native TransitionOptions nativeGetBackgroundPatternTransition(); + + private native void nativeSetBackgroundPatternTransition(long duration, long delay); + private native Object nativeGetBackgroundOpacity(); + private native TransitionOptions nativeGetBackgroundOpacityTransition(); + + private native void nativeSetBackgroundOpacityTransition(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/CircleLayer.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/CircleLayer.java index 43ec255e81..d5cc80f7e9 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/CircleLayer.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/CircleLayer.java @@ -8,6 +8,8 @@ import android.support.annotation.UiThread; import static com.mapbox.mapboxsdk.utils.ColorUtils.rgbaToColor; +import com.mapbox.mapboxsdk.style.layers.TransitionOptions; + /** * A filled circle. * @@ -100,6 +102,24 @@ public class CircleLayer extends Layer { return (PropertyValue) new PropertyValue("circle-radius", nativeGetCircleRadius()); } + /** + * Get the CircleRadius property transition options + * + * @return transition options for Float + */ + public TransitionOptions getCircleRadiusTransition() { + return nativeGetCircleRadiusTransition(); + } + + /** + * Set the CircleRadius property transition options + * + * @param options transition options for Float + */ + public void setCircleRadiusTransition(TransitionOptions options) { + nativeSetCircleRadiusTransition(options.getDuration(), options.getDelay()); + } + /** * Get the CircleColor property * @@ -126,6 +146,23 @@ public class CircleLayer extends Layer { } } + /** + * Get the CircleColor property transition options + * + * @return transition options for String + */ + public TransitionOptions getCircleColorTransition() { + return nativeGetCircleColorTransition(); + } + + /** + * Set the CircleColor property transition options + * + * @param options transition options for String + */ + public void setCircleColorTransition(TransitionOptions options) { + nativeSetCircleColorTransition(options.getDuration(), options.getDelay()); + } /** * Get the CircleBlur property @@ -137,6 +174,24 @@ public class CircleLayer extends Layer { return (PropertyValue) new PropertyValue("circle-blur", nativeGetCircleBlur()); } + /** + * Get the CircleBlur property transition options + * + * @return transition options for Float + */ + public TransitionOptions getCircleBlurTransition() { + return nativeGetCircleBlurTransition(); + } + + /** + * Set the CircleBlur property transition options + * + * @param options transition options for Float + */ + public void setCircleBlurTransition(TransitionOptions options) { + nativeSetCircleBlurTransition(options.getDuration(), options.getDelay()); + } + /** * Get the CircleOpacity property * @@ -147,6 +202,24 @@ public class CircleLayer extends Layer { return (PropertyValue) new PropertyValue("circle-opacity", nativeGetCircleOpacity()); } + /** + * Get the CircleOpacity property transition options + * + * @return transition options for Float + */ + public TransitionOptions getCircleOpacityTransition() { + return nativeGetCircleOpacityTransition(); + } + + /** + * Set the CircleOpacity property transition options + * + * @param options transition options for Float + */ + public void setCircleOpacityTransition(TransitionOptions options) { + nativeSetCircleOpacityTransition(options.getDuration(), options.getDelay()); + } + /** * Get the CircleTranslate property * @@ -157,6 +230,24 @@ public class CircleLayer extends Layer { return (PropertyValue) new PropertyValue("circle-translate", nativeGetCircleTranslate()); } + /** + * Get the CircleTranslate property transition options + * + * @return transition options for Float[] + */ + public TransitionOptions getCircleTranslateTransition() { + return nativeGetCircleTranslateTransition(); + } + + /** + * Set the CircleTranslate property transition options + * + * @param options transition options for Float[] + */ + public void setCircleTranslateTransition(TransitionOptions options) { + nativeSetCircleTranslateTransition(options.getDuration(), options.getDelay()); + } + /** * Get the CircleTranslateAnchor property * @@ -187,6 +278,24 @@ public class CircleLayer extends Layer { return (PropertyValue) new PropertyValue("circle-stroke-width", nativeGetCircleStrokeWidth()); } + /** + * Get the CircleStrokeWidth property transition options + * + * @return transition options for Float + */ + public TransitionOptions getCircleStrokeWidthTransition() { + return nativeGetCircleStrokeWidthTransition(); + } + + /** + * Set the CircleStrokeWidth property transition options + * + * @param options transition options for Float + */ + public void setCircleStrokeWidthTransition(TransitionOptions options) { + nativeSetCircleStrokeWidthTransition(options.getDuration(), options.getDelay()); + } + /** * Get the CircleStrokeColor property * @@ -213,6 +322,23 @@ public class CircleLayer extends Layer { } } + /** + * Get the CircleStrokeColor property transition options + * + * @return transition options for String + */ + public TransitionOptions getCircleStrokeColorTransition() { + return nativeGetCircleStrokeColorTransition(); + } + + /** + * Set the CircleStrokeColor property transition options + * + * @param options transition options for String + */ + public void setCircleStrokeColorTransition(TransitionOptions options) { + nativeSetCircleStrokeColorTransition(options.getDuration(), options.getDelay()); + } /** * Get the CircleStrokeOpacity property @@ -224,26 +350,75 @@ public class CircleLayer extends Layer { return (PropertyValue) new PropertyValue("circle-stroke-opacity", nativeGetCircleStrokeOpacity()); } + /** + * Get the CircleStrokeOpacity property transition options + * + * @return transition options for Float + */ + public TransitionOptions getCircleStrokeOpacityTransition() { + return nativeGetCircleStrokeOpacityTransition(); + } + + /** + * Set the CircleStrokeOpacity property transition options + * + * @param options transition options for Float + */ + public void setCircleStrokeOpacityTransition(TransitionOptions options) { + nativeSetCircleStrokeOpacityTransition(options.getDuration(), options.getDelay()); + } + private native Object nativeGetCircleRadius(); + private native TransitionOptions nativeGetCircleRadiusTransition(); + + private native void nativeSetCircleRadiusTransition(long duration, long delay); + private native Object nativeGetCircleColor(); + private native TransitionOptions nativeGetCircleColorTransition(); + + private native void nativeSetCircleColorTransition(long duration, long delay); + private native Object nativeGetCircleBlur(); + private native TransitionOptions nativeGetCircleBlurTransition(); + + private native void nativeSetCircleBlurTransition(long duration, long delay); + private native Object nativeGetCircleOpacity(); + private native TransitionOptions nativeGetCircleOpacityTransition(); + + private native void nativeSetCircleOpacityTransition(long duration, long delay); + private native Object nativeGetCircleTranslate(); + private native TransitionOptions nativeGetCircleTranslateTransition(); + + private native void nativeSetCircleTranslateTransition(long duration, long delay); + private native Object nativeGetCircleTranslateAnchor(); private native Object nativeGetCirclePitchScale(); private native Object nativeGetCircleStrokeWidth(); + private native TransitionOptions nativeGetCircleStrokeWidthTransition(); + + private native void nativeSetCircleStrokeWidthTransition(long duration, long delay); + private native Object nativeGetCircleStrokeColor(); + private native TransitionOptions nativeGetCircleStrokeColorTransition(); + + private native void nativeSetCircleStrokeColorTransition(long duration, long delay); + private native Object nativeGetCircleStrokeOpacity(); + private native TransitionOptions nativeGetCircleStrokeOpacityTransition(); + + private native void nativeSetCircleStrokeOpacityTransition(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/FillLayer.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/FillLayer.java index 8989f3a2ec..b765aa6642 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/FillLayer.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/FillLayer.java @@ -8,6 +8,8 @@ import android.support.annotation.UiThread; import static com.mapbox.mapboxsdk.utils.ColorUtils.rgbaToColor; +import com.mapbox.mapboxsdk.style.layers.TransitionOptions; + /** * A filled polygon with an optional stroked border. * @@ -110,6 +112,24 @@ public class FillLayer extends Layer { return (PropertyValue) new PropertyValue("fill-opacity", nativeGetFillOpacity()); } + /** + * Get the FillOpacity property transition options + * + * @return transition options for Float + */ + public TransitionOptions getFillOpacityTransition() { + return nativeGetFillOpacityTransition(); + } + + /** + * Set the FillOpacity property transition options + * + * @param options transition options for Float + */ + public void setFillOpacityTransition(TransitionOptions options) { + nativeSetFillOpacityTransition(options.getDuration(), options.getDelay()); + } + /** * Get the FillColor property * @@ -136,6 +156,23 @@ public class FillLayer extends Layer { } } + /** + * Get the FillColor property transition options + * + * @return transition options for String + */ + public TransitionOptions getFillColorTransition() { + return nativeGetFillColorTransition(); + } + + /** + * Set the FillColor property transition options + * + * @param options transition options for String + */ + public void setFillColorTransition(TransitionOptions options) { + nativeSetFillColorTransition(options.getDuration(), options.getDelay()); + } /** * Get the FillOutlineColor property @@ -163,6 +200,23 @@ public class FillLayer extends Layer { } } + /** + * Get the FillOutlineColor property transition options + * + * @return transition options for String + */ + public TransitionOptions getFillOutlineColorTransition() { + return nativeGetFillOutlineColorTransition(); + } + + /** + * Set the FillOutlineColor property transition options + * + * @param options transition options for String + */ + public void setFillOutlineColorTransition(TransitionOptions options) { + nativeSetFillOutlineColorTransition(options.getDuration(), options.getDelay()); + } /** * Get the FillTranslate property @@ -174,6 +228,24 @@ public class FillLayer extends Layer { return (PropertyValue) new PropertyValue("fill-translate", nativeGetFillTranslate()); } + /** + * Get the FillTranslate property transition options + * + * @return transition options for Float[] + */ + public TransitionOptions getFillTranslateTransition() { + return nativeGetFillTranslateTransition(); + } + + /** + * Set the FillTranslate property transition options + * + * @param options transition options for Float[] + */ + public void setFillTranslateTransition(TransitionOptions options) { + nativeSetFillTranslateTransition(options.getDuration(), options.getDelay()); + } + /** * Get the FillTranslateAnchor property * @@ -194,20 +266,57 @@ public class FillLayer extends Layer { return (PropertyValue) new PropertyValue("fill-pattern", nativeGetFillPattern()); } + /** + * Get the FillPattern property transition options + * + * @return transition options for String + */ + public TransitionOptions getFillPatternTransition() { + return nativeGetFillPatternTransition(); + } + + /** + * Set the FillPattern property transition options + * + * @param options transition options for String + */ + public void setFillPatternTransition(TransitionOptions options) { + nativeSetFillPatternTransition(options.getDuration(), options.getDelay()); + } + private native Object nativeGetFillAntialias(); private native Object nativeGetFillOpacity(); + private native TransitionOptions nativeGetFillOpacityTransition(); + + private native void nativeSetFillOpacityTransition(long duration, long delay); + private native Object nativeGetFillColor(); + private native TransitionOptions nativeGetFillColorTransition(); + + private native void nativeSetFillColorTransition(long duration, long delay); + private native Object nativeGetFillOutlineColor(); + private native TransitionOptions nativeGetFillOutlineColorTransition(); + + private native void nativeSetFillOutlineColorTransition(long duration, long delay); + private native Object nativeGetFillTranslate(); + private native TransitionOptions nativeGetFillTranslateTransition(); + + private native void nativeSetFillTranslateTransition(long duration, long delay); + private native Object nativeGetFillTranslateAnchor(); private native Object nativeGetFillPattern(); + private native TransitionOptions nativeGetFillPatternTransition(); + + private native void nativeSetFillPatternTransition(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/LineLayer.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/LineLayer.java index 6992c22ace..575b582988 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/LineLayer.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/LineLayer.java @@ -8,6 +8,8 @@ import android.support.annotation.UiThread; import static com.mapbox.mapboxsdk.utils.ColorUtils.rgbaToColor; +import com.mapbox.mapboxsdk.style.layers.TransitionOptions; + /** * A stroked line. * @@ -140,6 +142,24 @@ public class LineLayer extends Layer { return (PropertyValue) new PropertyValue("line-opacity", nativeGetLineOpacity()); } + /** + * Get the LineOpacity property transition options + * + * @return transition options for Float + */ + public TransitionOptions getLineOpacityTransition() { + return nativeGetLineOpacityTransition(); + } + + /** + * Set the LineOpacity property transition options + * + * @param options transition options for Float + */ + public void setLineOpacityTransition(TransitionOptions options) { + nativeSetLineOpacityTransition(options.getDuration(), options.getDelay()); + } + /** * Get the LineColor property * @@ -166,6 +186,23 @@ public class LineLayer extends Layer { } } + /** + * Get the LineColor property transition options + * + * @return transition options for String + */ + public TransitionOptions getLineColorTransition() { + return nativeGetLineColorTransition(); + } + + /** + * Set the LineColor property transition options + * + * @param options transition options for String + */ + public void setLineColorTransition(TransitionOptions options) { + nativeSetLineColorTransition(options.getDuration(), options.getDelay()); + } /** * Get the LineTranslate property @@ -177,6 +214,24 @@ public class LineLayer extends Layer { return (PropertyValue) new PropertyValue("line-translate", nativeGetLineTranslate()); } + /** + * Get the LineTranslate property transition options + * + * @return transition options for Float[] + */ + public TransitionOptions getLineTranslateTransition() { + return nativeGetLineTranslateTransition(); + } + + /** + * Set the LineTranslate property transition options + * + * @param options transition options for Float[] + */ + public void setLineTranslateTransition(TransitionOptions options) { + nativeSetLineTranslateTransition(options.getDuration(), options.getDelay()); + } + /** * Get the LineTranslateAnchor property * @@ -197,6 +252,24 @@ public class LineLayer extends Layer { return (PropertyValue) new PropertyValue("line-width", nativeGetLineWidth()); } + /** + * Get the LineWidth property transition options + * + * @return transition options for Float + */ + public TransitionOptions getLineWidthTransition() { + return nativeGetLineWidthTransition(); + } + + /** + * Set the LineWidth property transition options + * + * @param options transition options for Float + */ + public void setLineWidthTransition(TransitionOptions options) { + nativeSetLineWidthTransition(options.getDuration(), options.getDelay()); + } + /** * Get the LineGapWidth property * @@ -207,6 +280,24 @@ public class LineLayer extends Layer { return (PropertyValue) new PropertyValue("line-gap-width", nativeGetLineGapWidth()); } + /** + * Get the LineGapWidth property transition options + * + * @return transition options for Float + */ + public TransitionOptions getLineGapWidthTransition() { + return nativeGetLineGapWidthTransition(); + } + + /** + * Set the LineGapWidth property transition options + * + * @param options transition options for Float + */ + public void setLineGapWidthTransition(TransitionOptions options) { + nativeSetLineGapWidthTransition(options.getDuration(), options.getDelay()); + } + /** * Get the LineOffset property * @@ -217,6 +308,24 @@ public class LineLayer extends Layer { return (PropertyValue) new PropertyValue("line-offset", nativeGetLineOffset()); } + /** + * Get the LineOffset property transition options + * + * @return transition options for Float + */ + public TransitionOptions getLineOffsetTransition() { + return nativeGetLineOffsetTransition(); + } + + /** + * Set the LineOffset property transition options + * + * @param options transition options for Float + */ + public void setLineOffsetTransition(TransitionOptions options) { + nativeSetLineOffsetTransition(options.getDuration(), options.getDelay()); + } + /** * Get the LineBlur property * @@ -227,6 +336,24 @@ public class LineLayer extends Layer { return (PropertyValue) new PropertyValue("line-blur", nativeGetLineBlur()); } + /** + * Get the LineBlur property transition options + * + * @return transition options for Float + */ + public TransitionOptions getLineBlurTransition() { + return nativeGetLineBlurTransition(); + } + + /** + * Set the LineBlur property transition options + * + * @param options transition options for Float + */ + public void setLineBlurTransition(TransitionOptions options) { + nativeSetLineBlurTransition(options.getDuration(), options.getDelay()); + } + /** * Get the LineDasharray property * @@ -237,6 +364,24 @@ public class LineLayer extends Layer { return (PropertyValue) new PropertyValue("line-dasharray", nativeGetLineDasharray()); } + /** + * Get the LineDasharray property transition options + * + * @return transition options for Float[] + */ + public TransitionOptions getLineDasharrayTransition() { + return nativeGetLineDasharrayTransition(); + } + + /** + * Set the LineDasharray property transition options + * + * @param options transition options for Float[] + */ + public void setLineDasharrayTransition(TransitionOptions options) { + nativeSetLineDasharrayTransition(options.getDuration(), options.getDelay()); + } + /** * Get the LinePattern property * @@ -247,6 +392,24 @@ public class LineLayer extends Layer { return (PropertyValue) new PropertyValue("line-pattern", nativeGetLinePattern()); } + /** + * Get the LinePattern property transition options + * + * @return transition options for String + */ + public TransitionOptions getLinePatternTransition() { + return nativeGetLinePatternTransition(); + } + + /** + * Set the LinePattern property transition options + * + * @param options transition options for String + */ + public void setLinePatternTransition(TransitionOptions options) { + nativeSetLinePatternTransition(options.getDuration(), options.getDelay()); + } + private native Object nativeGetLineCap(); private native Object nativeGetLineJoin(); @@ -257,24 +420,59 @@ public class LineLayer extends Layer { private native Object nativeGetLineOpacity(); + private native TransitionOptions nativeGetLineOpacityTransition(); + + private native void nativeSetLineOpacityTransition(long duration, long delay); + private native Object nativeGetLineColor(); + private native TransitionOptions nativeGetLineColorTransition(); + + private native void nativeSetLineColorTransition(long duration, long delay); + private native Object nativeGetLineTranslate(); + private native TransitionOptions nativeGetLineTranslateTransition(); + + private native void nativeSetLineTranslateTransition(long duration, long delay); + private native Object nativeGetLineTranslateAnchor(); private native Object nativeGetLineWidth(); + private native TransitionOptions nativeGetLineWidthTransition(); + + private native void nativeSetLineWidthTransition(long duration, long delay); + private native Object nativeGetLineGapWidth(); + private native TransitionOptions nativeGetLineGapWidthTransition(); + + private native void nativeSetLineGapWidthTransition(long duration, long delay); + private native Object nativeGetLineOffset(); + private native TransitionOptions nativeGetLineOffsetTransition(); + + private native void nativeSetLineOffsetTransition(long duration, long delay); + private native Object nativeGetLineBlur(); + private native TransitionOptions nativeGetLineBlurTransition(); + + private native void nativeSetLineBlurTransition(long duration, long delay); + private native Object nativeGetLineDasharray(); + private native TransitionOptions nativeGetLineDasharrayTransition(); + + private native void nativeSetLineDasharrayTransition(long duration, long delay); + private native Object nativeGetLinePattern(); + private native TransitionOptions nativeGetLinePatternTransition(); + + private native void nativeSetLinePatternTransition(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/RasterLayer.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/RasterLayer.java index 1871686429..e67e71b61d 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/RasterLayer.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/RasterLayer.java @@ -8,6 +8,8 @@ import android.support.annotation.UiThread; import static com.mapbox.mapboxsdk.utils.ColorUtils.rgbaToColor; +import com.mapbox.mapboxsdk.style.layers.TransitionOptions; + /** * Raster map textures such as satellite imagery. * @@ -80,6 +82,24 @@ public class RasterLayer extends Layer { return (PropertyValue) new PropertyValue("raster-opacity", nativeGetRasterOpacity()); } + /** + * Get the RasterOpacity property transition options + * + * @return transition options for Float + */ + public TransitionOptions getRasterOpacityTransition() { + return nativeGetRasterOpacityTransition(); + } + + /** + * Set the RasterOpacity property transition options + * + * @param options transition options for Float + */ + public void setRasterOpacityTransition(TransitionOptions options) { + nativeSetRasterOpacityTransition(options.getDuration(), options.getDelay()); + } + /** * Get the RasterHueRotate property * @@ -90,6 +110,24 @@ public class RasterLayer extends Layer { return (PropertyValue) new PropertyValue("raster-hue-rotate", nativeGetRasterHueRotate()); } + /** + * Get the RasterHueRotate property transition options + * + * @return transition options for Float + */ + public TransitionOptions getRasterHueRotateTransition() { + return nativeGetRasterHueRotateTransition(); + } + + /** + * Set the RasterHueRotate property transition options + * + * @param options transition options for Float + */ + public void setRasterHueRotateTransition(TransitionOptions options) { + nativeSetRasterHueRotateTransition(options.getDuration(), options.getDelay()); + } + /** * Get the RasterBrightnessMin property * @@ -100,6 +138,24 @@ public class RasterLayer extends Layer { return (PropertyValue) new PropertyValue("raster-brightness-min", nativeGetRasterBrightnessMin()); } + /** + * Get the RasterBrightnessMin property transition options + * + * @return transition options for Float + */ + public TransitionOptions getRasterBrightnessMinTransition() { + return nativeGetRasterBrightnessMinTransition(); + } + + /** + * Set the RasterBrightnessMin property transition options + * + * @param options transition options for Float + */ + public void setRasterBrightnessMinTransition(TransitionOptions options) { + nativeSetRasterBrightnessMinTransition(options.getDuration(), options.getDelay()); + } + /** * Get the RasterBrightnessMax property * @@ -110,6 +166,24 @@ public class RasterLayer extends Layer { return (PropertyValue) new PropertyValue("raster-brightness-max", nativeGetRasterBrightnessMax()); } + /** + * Get the RasterBrightnessMax property transition options + * + * @return transition options for Float + */ + public TransitionOptions getRasterBrightnessMaxTransition() { + return nativeGetRasterBrightnessMaxTransition(); + } + + /** + * Set the RasterBrightnessMax property transition options + * + * @param options transition options for Float + */ + public void setRasterBrightnessMaxTransition(TransitionOptions options) { + nativeSetRasterBrightnessMaxTransition(options.getDuration(), options.getDelay()); + } + /** * Get the RasterSaturation property * @@ -120,6 +194,24 @@ public class RasterLayer extends Layer { return (PropertyValue) new PropertyValue("raster-saturation", nativeGetRasterSaturation()); } + /** + * Get the RasterSaturation property transition options + * + * @return transition options for Float + */ + public TransitionOptions getRasterSaturationTransition() { + return nativeGetRasterSaturationTransition(); + } + + /** + * Set the RasterSaturation property transition options + * + * @param options transition options for Float + */ + public void setRasterSaturationTransition(TransitionOptions options) { + nativeSetRasterSaturationTransition(options.getDuration(), options.getDelay()); + } + /** * Get the RasterContrast property * @@ -130,6 +222,24 @@ public class RasterLayer extends Layer { return (PropertyValue) new PropertyValue("raster-contrast", nativeGetRasterContrast()); } + /** + * Get the RasterContrast property transition options + * + * @return transition options for Float + */ + public TransitionOptions getRasterContrastTransition() { + return nativeGetRasterContrastTransition(); + } + + /** + * Set the RasterContrast property transition options + * + * @param options transition options for Float + */ + public void setRasterContrastTransition(TransitionOptions options) { + nativeSetRasterContrastTransition(options.getDuration(), options.getDelay()); + } + /** * Get the RasterFadeDuration property * @@ -140,20 +250,65 @@ public class RasterLayer extends Layer { return (PropertyValue) new PropertyValue("raster-fade-duration", nativeGetRasterFadeDuration()); } + /** + * Get the RasterFadeDuration property transition options + * + * @return transition options for Float + */ + public TransitionOptions getRasterFadeDurationTransition() { + return nativeGetRasterFadeDurationTransition(); + } + + /** + * Set the RasterFadeDuration property transition options + * + * @param options transition options for Float + */ + public void setRasterFadeDurationTransition(TransitionOptions options) { + nativeSetRasterFadeDurationTransition(options.getDuration(), options.getDelay()); + } + private native Object nativeGetRasterOpacity(); + private native TransitionOptions nativeGetRasterOpacityTransition(); + + private native void nativeSetRasterOpacityTransition(long duration, long delay); + private native Object nativeGetRasterHueRotate(); + private native TransitionOptions nativeGetRasterHueRotateTransition(); + + private native void nativeSetRasterHueRotateTransition(long duration, long delay); + private native Object nativeGetRasterBrightnessMin(); + private native TransitionOptions nativeGetRasterBrightnessMinTransition(); + + private native void nativeSetRasterBrightnessMinTransition(long duration, long delay); + private native Object nativeGetRasterBrightnessMax(); + private native TransitionOptions nativeGetRasterBrightnessMaxTransition(); + + private native void nativeSetRasterBrightnessMaxTransition(long duration, long delay); + private native Object nativeGetRasterSaturation(); + private native TransitionOptions nativeGetRasterSaturationTransition(); + + private native void nativeSetRasterSaturationTransition(long duration, long delay); + private native Object nativeGetRasterContrast(); + private native TransitionOptions nativeGetRasterContrastTransition(); + + private native void nativeSetRasterContrastTransition(long duration, long delay); + private native Object nativeGetRasterFadeDuration(); + private native TransitionOptions nativeGetRasterFadeDurationTransition(); + + private native void nativeSetRasterFadeDurationTransition(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/SymbolLayer.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/SymbolLayer.java index c1efdc9636..318991c032 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/SymbolLayer.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/SymbolLayer.java @@ -8,6 +8,8 @@ import android.support.annotation.UiThread; import static com.mapbox.mapboxsdk.utils.ColorUtils.rgbaToColor; +import com.mapbox.mapboxsdk.style.layers.TransitionOptions; + /** * An icon or a text label. * @@ -440,6 +442,24 @@ public class SymbolLayer extends Layer { return (PropertyValue) new PropertyValue("icon-opacity", nativeGetIconOpacity()); } + /** + * Get the IconOpacity property transition options + * + * @return transition options for Float + */ + public TransitionOptions getIconOpacityTransition() { + return nativeGetIconOpacityTransition(); + } + + /** + * Set the IconOpacity property transition options + * + * @param options transition options for Float + */ + public void setIconOpacityTransition(TransitionOptions options) { + nativeSetIconOpacityTransition(options.getDuration(), options.getDelay()); + } + /** * Get the IconColor property * @@ -466,6 +486,23 @@ public class SymbolLayer extends Layer { } } + /** + * Get the IconColor property transition options + * + * @return transition options for String + */ + public TransitionOptions getIconColorTransition() { + return nativeGetIconColorTransition(); + } + + /** + * Set the IconColor property transition options + * + * @param options transition options for String + */ + public void setIconColorTransition(TransitionOptions options) { + nativeSetIconColorTransition(options.getDuration(), options.getDelay()); + } /** * Get the IconHaloColor property @@ -493,6 +530,23 @@ public class SymbolLayer extends Layer { } } + /** + * Get the IconHaloColor property transition options + * + * @return transition options for String + */ + public TransitionOptions getIconHaloColorTransition() { + return nativeGetIconHaloColorTransition(); + } + + /** + * Set the IconHaloColor property transition options + * + * @param options transition options for String + */ + public void setIconHaloColorTransition(TransitionOptions options) { + nativeSetIconHaloColorTransition(options.getDuration(), options.getDelay()); + } /** * Get the IconHaloWidth property @@ -504,6 +558,24 @@ public class SymbolLayer extends Layer { return (PropertyValue) new PropertyValue("icon-halo-width", nativeGetIconHaloWidth()); } + /** + * Get the IconHaloWidth property transition options + * + * @return transition options for Float + */ + public TransitionOptions getIconHaloWidthTransition() { + return nativeGetIconHaloWidthTransition(); + } + + /** + * Set the IconHaloWidth property transition options + * + * @param options transition options for Float + */ + public void setIconHaloWidthTransition(TransitionOptions options) { + nativeSetIconHaloWidthTransition(options.getDuration(), options.getDelay()); + } + /** * Get the IconHaloBlur property * @@ -514,6 +586,24 @@ public class SymbolLayer extends Layer { return (PropertyValue) new PropertyValue("icon-halo-blur", nativeGetIconHaloBlur()); } + /** + * Get the IconHaloBlur property transition options + * + * @return transition options for Float + */ + public TransitionOptions getIconHaloBlurTransition() { + return nativeGetIconHaloBlurTransition(); + } + + /** + * Set the IconHaloBlur property transition options + * + * @param options transition options for Float + */ + public void setIconHaloBlurTransition(TransitionOptions options) { + nativeSetIconHaloBlurTransition(options.getDuration(), options.getDelay()); + } + /** * Get the IconTranslate property * @@ -524,6 +614,24 @@ public class SymbolLayer extends Layer { return (PropertyValue) new PropertyValue("icon-translate", nativeGetIconTranslate()); } + /** + * Get the IconTranslate property transition options + * + * @return transition options for Float[] + */ + public TransitionOptions getIconTranslateTransition() { + return nativeGetIconTranslateTransition(); + } + + /** + * Set the IconTranslate property transition options + * + * @param options transition options for Float[] + */ + public void setIconTranslateTransition(TransitionOptions options) { + nativeSetIconTranslateTransition(options.getDuration(), options.getDelay()); + } + /** * Get the IconTranslateAnchor property * @@ -544,6 +652,24 @@ public class SymbolLayer extends Layer { return (PropertyValue) new PropertyValue("text-opacity", nativeGetTextOpacity()); } + /** + * Get the TextOpacity property transition options + * + * @return transition options for Float + */ + public TransitionOptions getTextOpacityTransition() { + return nativeGetTextOpacityTransition(); + } + + /** + * Set the TextOpacity property transition options + * + * @param options transition options for Float + */ + public void setTextOpacityTransition(TransitionOptions options) { + nativeSetTextOpacityTransition(options.getDuration(), options.getDelay()); + } + /** * Get the TextColor property * @@ -570,6 +696,23 @@ public class SymbolLayer extends Layer { } } + /** + * Get the TextColor property transition options + * + * @return transition options for String + */ + public TransitionOptions getTextColorTransition() { + return nativeGetTextColorTransition(); + } + + /** + * Set the TextColor property transition options + * + * @param options transition options for String + */ + public void setTextColorTransition(TransitionOptions options) { + nativeSetTextColorTransition(options.getDuration(), options.getDelay()); + } /** * Get the TextHaloColor property @@ -597,6 +740,23 @@ public class SymbolLayer extends Layer { } } + /** + * Get the TextHaloColor property transition options + * + * @return transition options for String + */ + public TransitionOptions getTextHaloColorTransition() { + return nativeGetTextHaloColorTransition(); + } + + /** + * Set the TextHaloColor property transition options + * + * @param options transition options for String + */ + public void setTextHaloColorTransition(TransitionOptions options) { + nativeSetTextHaloColorTransition(options.getDuration(), options.getDelay()); + } /** * Get the TextHaloWidth property @@ -608,6 +768,24 @@ public class SymbolLayer extends Layer { return (PropertyValue) new PropertyValue("text-halo-width", nativeGetTextHaloWidth()); } + /** + * Get the TextHaloWidth property transition options + * + * @return transition options for Float + */ + public TransitionOptions getTextHaloWidthTransition() { + return nativeGetTextHaloWidthTransition(); + } + + /** + * Set the TextHaloWidth property transition options + * + * @param options transition options for Float + */ + public void setTextHaloWidthTransition(TransitionOptions options) { + nativeSetTextHaloWidthTransition(options.getDuration(), options.getDelay()); + } + /** * Get the TextHaloBlur property * @@ -618,6 +796,24 @@ public class SymbolLayer extends Layer { return (PropertyValue) new PropertyValue("text-halo-blur", nativeGetTextHaloBlur()); } + /** + * Get the TextHaloBlur property transition options + * + * @return transition options for Float + */ + public TransitionOptions getTextHaloBlurTransition() { + return nativeGetTextHaloBlurTransition(); + } + + /** + * Set the TextHaloBlur property transition options + * + * @param options transition options for Float + */ + public void setTextHaloBlurTransition(TransitionOptions options) { + nativeSetTextHaloBlurTransition(options.getDuration(), options.getDelay()); + } + /** * Get the TextTranslate property * @@ -628,6 +824,24 @@ public class SymbolLayer extends Layer { return (PropertyValue) new PropertyValue("text-translate", nativeGetTextTranslate()); } + /** + * Get the TextTranslate property transition options + * + * @return transition options for Float[] + */ + public TransitionOptions getTextTranslateTransition() { + return nativeGetTextTranslateTransition(); + } + + /** + * Set the TextTranslate property transition options + * + * @param options transition options for Float[] + */ + public void setTextTranslateTransition(TransitionOptions options) { + nativeSetTextTranslateTransition(options.getDuration(), options.getDelay()); + } + /** * Get the TextTranslateAnchor property * @@ -708,32 +922,79 @@ public class SymbolLayer extends Layer { private native Object nativeGetIconOpacity(); + private native TransitionOptions nativeGetIconOpacityTransition(); + + private native void nativeSetIconOpacityTransition(long duration, long delay); + private native Object nativeGetIconColor(); + private native TransitionOptions nativeGetIconColorTransition(); + + private native void nativeSetIconColorTransition(long duration, long delay); + private native Object nativeGetIconHaloColor(); + private native TransitionOptions nativeGetIconHaloColorTransition(); + + private native void nativeSetIconHaloColorTransition(long duration, long delay); + private native Object nativeGetIconHaloWidth(); + private native TransitionOptions nativeGetIconHaloWidthTransition(); + + private native void nativeSetIconHaloWidthTransition(long duration, long delay); + private native Object nativeGetIconHaloBlur(); + private native TransitionOptions nativeGetIconHaloBlurTransition(); + + private native void nativeSetIconHaloBlurTransition(long duration, long delay); + private native Object nativeGetIconTranslate(); + private native TransitionOptions nativeGetIconTranslateTransition(); + + private native void nativeSetIconTranslateTransition(long duration, long delay); + private native Object nativeGetIconTranslateAnchor(); private native Object nativeGetTextOpacity(); + private native TransitionOptions nativeGetTextOpacityTransition(); + + private native void nativeSetTextOpacityTransition(long duration, long delay); + private native Object nativeGetTextColor(); + private native TransitionOptions nativeGetTextColorTransition(); + + private native void nativeSetTextColorTransition(long duration, long delay); + private native Object nativeGetTextHaloColor(); + private native TransitionOptions nativeGetTextHaloColorTransition(); + + private native void nativeSetTextHaloColorTransition(long duration, long delay); + private native Object nativeGetTextHaloWidth(); + private native TransitionOptions nativeGetTextHaloWidthTransition(); + + private native void nativeSetTextHaloWidthTransition(long duration, long delay); + private native Object nativeGetTextHaloBlur(); + private native TransitionOptions nativeGetTextHaloBlurTransition(); + + private native void nativeSetTextHaloBlurTransition(long duration, long delay); + private native Object nativeGetTextTranslate(); - private native Object nativeGetTextTranslateAnchor(); + private native TransitionOptions nativeGetTextTranslateTransition(); + private native void nativeSetTextTranslateTransition(long duration, long delay); + + private native Object nativeGetTextTranslateAnchor(); @Override protected native void finalize() throws Throwable; diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/TransitionOptions.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/TransitionOptions.java new file mode 100644 index 0000000000..a46c11b35c --- /dev/null +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/TransitionOptions.java @@ -0,0 +1,56 @@ +package com.mapbox.mapboxsdk.style.layers; + +public class TransitionOptions { + + private long duration; + private long delay; + + public TransitionOptions(long duration, long delay) { + this.duration = duration; + this.delay = delay; + } + + public static TransitionOptions fromTransitionOptions(long duration, long delay) { + return new TransitionOptions(duration, delay); + } + + public long getDuration() { + return duration; + } + + public long getDelay() { + return delay; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + TransitionOptions that = (TransitionOptions) o; + + if (duration != that.duration) { + return false; + } + return delay == that.delay; + } + + @Override + public int hashCode() { + int result = (int) (duration ^ (duration >>> 32)); + result = 31 * result + (int) (delay ^ (delay >>> 32)); + return result; + } + + @Override + public String toString() { + return "TransitionOptions{" + + "duration=" + duration + + ", delay=" + delay + + '}'; + } +} diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/layer.java.ejs b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/layer.java.ejs index 5eab4c355e..316b3aeac1 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/layer.java.ejs +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/layer.java.ejs @@ -13,6 +13,8 @@ import android.support.annotation.UiThread; import static com.mapbox.mapboxsdk.utils.ColorUtils.rgbaToColor; +import com.mapbox.mapboxsdk.style.layers.TransitionOptions; + /** * <%- doc %> * @@ -110,8 +112,8 @@ public class <%- camelize(type) %>Layer extends Layer { } // Property getters - <% for (const property of properties) { -%> + /** * Get the <%- camelize(property.name) %> property * @@ -138,15 +140,39 @@ public class <%- camelize(type) %>Layer extends Layer { throw new RuntimeException("<%- property.name %> was set as a Function"); } } - <% } -%> +<% if (property.transition) { -%> + + /** + * Get the <%- camelize(property.name) %> property transition options + * + * @return transition options for <%- propertyType(property) %> + */ + public TransitionOptions get<%- camelize(property.name) %>Transition() { + return nativeGet<%- camelize(property.name) %>Transition(); + } + /** + * Set the <%- camelize(property.name) %> property transition options + * + * @param options transition options for <%- propertyType(property) %> + */ + public void set<%- camelize(property.name) %>Transition(TransitionOptions options) { + nativeSet<%- camelize(property.name) %>Transition(options.getDuration(), options.getDelay()); + } <% } -%> +<% } -%> + <% for (const property of properties) { -%> private native Object nativeGet<%- camelize(property.name) %>(); -<% } -%> +<% if (property.transition) { -%> + private native TransitionOptions nativeGet<%- camelize(property.name) %>Transition(); + + private native void nativeSet<%- camelize(property.name) %>Transition(long duration, long delay); +<% } -%> +<% } -%> @Override protected native void finalize() throws Throwable; 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 510f477bce..4f94dcc28b 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 @@ -36,6 +36,8 @@ 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; + /** * Basic smoke tests for BackgroundLayer */ @@ -75,6 +77,18 @@ public class BackgroundLayerTest extends BaseStyleTest { assertEquals(layer.getVisibility().getValue(), NONE); } + @Test + public void testBackgroundColorTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("background-colorTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setBackgroundColorTransition(options); + assertEquals(layer.getBackgroundColorTransition(), options); + } + @Test public void testBackgroundColorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -123,6 +137,18 @@ public class BackgroundLayerTest extends BaseStyleTest { assertEquals(layer.getBackgroundColorAsInt(), Color.RED); } + @Test + public void testBackgroundPatternTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("background-patternTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setBackgroundPatternTransition(options); + assertEquals(layer.getBackgroundPatternTransition(), options); + } + @Test public void testBackgroundPatternAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -159,6 +185,18 @@ public class BackgroundLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getBackgroundPattern().getFunction().getStops()).size()); } + @Test + public void testBackgroundOpacityTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("background-opacityTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setBackgroundOpacityTransition(options); + assertEquals(layer.getBackgroundOpacityTransition(), options); + } + @Test public void testBackgroundOpacityAsConstant() { checkViewIsDisplayed(R.id.mapView); diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/CircleLayerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/CircleLayerTest.java index a8f35356b5..7b8a03fb35 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/CircleLayerTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/CircleLayerTest.java @@ -36,6 +36,8 @@ 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; + /** * Basic smoke tests for CircleLayer */ @@ -81,6 +83,18 @@ public class CircleLayerTest extends BaseStyleTest { assertEquals(layer.getVisibility().getValue(), NONE); } + @Test + public void testCircleRadiusTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("circle-radiusTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setCircleRadiusTransition(options); + assertEquals(layer.getCircleRadiusTransition(), options); + } + @Test public void testCircleRadiusAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -226,6 +240,18 @@ public class CircleLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testCircleColorTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("circle-colorTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setCircleColorTransition(options); + assertEquals(layer.getCircleColorTransition(), options); + } + @Test public void testCircleColorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -348,6 +374,18 @@ public class CircleLayerTest extends BaseStyleTest { assertEquals(layer.getCircleColorAsInt(), Color.RED); } + @Test + public void testCircleBlurTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("circle-blurTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setCircleBlurTransition(options); + assertEquals(layer.getCircleBlurTransition(), options); + } + @Test public void testCircleBlurAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -493,6 +531,18 @@ public class CircleLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testCircleOpacityTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("circle-opacityTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setCircleOpacityTransition(options); + assertEquals(layer.getCircleOpacityTransition(), options); + } + @Test public void testCircleOpacityAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -638,6 +688,18 @@ public class CircleLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testCircleTranslateTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("circle-translateTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setCircleTranslateTransition(options); + assertEquals(layer.getCircleTranslateTransition(), options); + } + @Test public void testCircleTranslateAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -675,6 +737,7 @@ public class CircleLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getCircleTranslate().getFunction().getStops()).size()); } + @Test public void testCircleTranslateAnchorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -711,6 +774,7 @@ public class CircleLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getCircleTranslateAnchor().getFunction().getStops()).size()); } + @Test public void testCirclePitchScaleAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -747,6 +811,18 @@ public class CircleLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getCirclePitchScale().getFunction().getStops()).size()); } + @Test + public void testCircleStrokeWidthTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("circle-stroke-widthTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setCircleStrokeWidthTransition(options); + assertEquals(layer.getCircleStrokeWidthTransition(), options); + } + @Test public void testCircleStrokeWidthAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -892,6 +968,18 @@ public class CircleLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testCircleStrokeColorTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("circle-stroke-colorTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setCircleStrokeColorTransition(options); + assertEquals(layer.getCircleStrokeColorTransition(), options); + } + @Test public void testCircleStrokeColorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1014,6 +1102,18 @@ public class CircleLayerTest extends BaseStyleTest { assertEquals(layer.getCircleStrokeColorAsInt(), Color.RED); } + @Test + public void testCircleStrokeOpacityTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("circle-stroke-opacityTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setCircleStrokeOpacityTransition(options); + assertEquals(layer.getCircleStrokeOpacityTransition(), options); + } + @Test public void testCircleStrokeOpacityAsConstant() { checkViewIsDisplayed(R.id.mapView); diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/FillLayerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/FillLayerTest.java index a1d362f0f9..63dac76edd 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/FillLayerTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/FillLayerTest.java @@ -36,6 +36,8 @@ 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; + /** * Basic smoke tests for FillLayer */ @@ -81,6 +83,7 @@ public class FillLayerTest extends BaseStyleTest { assertEquals(layer.getVisibility().getValue(), NONE); } + @Test public void testFillAntialiasAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -117,6 +120,18 @@ public class FillLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getFillAntialias().getFunction().getStops()).size()); } + @Test + public void testFillOpacityTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("fill-opacityTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setFillOpacityTransition(options); + assertEquals(layer.getFillOpacityTransition(), options); + } + @Test public void testFillOpacityAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -262,6 +277,18 @@ public class FillLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testFillColorTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("fill-colorTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setFillColorTransition(options); + assertEquals(layer.getFillColorTransition(), options); + } + @Test public void testFillColorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -384,6 +411,18 @@ public class FillLayerTest extends BaseStyleTest { assertEquals(layer.getFillColorAsInt(), Color.RED); } + @Test + public void testFillOutlineColorTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("fill-outline-colorTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setFillOutlineColorTransition(options); + assertEquals(layer.getFillOutlineColorTransition(), options); + } + @Test public void testFillOutlineColorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -506,6 +545,18 @@ public class FillLayerTest extends BaseStyleTest { assertEquals(layer.getFillOutlineColorAsInt(), Color.RED); } + @Test + public void testFillTranslateTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("fill-translateTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setFillTranslateTransition(options); + assertEquals(layer.getFillTranslateTransition(), options); + } + @Test public void testFillTranslateAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -543,6 +594,7 @@ public class FillLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getFillTranslate().getFunction().getStops()).size()); } + @Test public void testFillTranslateAnchorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -579,6 +631,18 @@ public class FillLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getFillTranslateAnchor().getFunction().getStops()).size()); } + @Test + public void testFillPatternTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("fill-patternTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setFillPatternTransition(options); + assertEquals(layer.getFillPatternTransition(), options); + } + @Test public void testFillPatternAsConstant() { checkViewIsDisplayed(R.id.mapView); diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/LineLayerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/LineLayerTest.java index 466873f9e5..110d23dd90 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/LineLayerTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/LineLayerTest.java @@ -36,6 +36,8 @@ 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; + /** * Basic smoke tests for LineLayer */ @@ -81,6 +83,7 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(layer.getVisibility().getValue(), NONE); } + @Test public void testLineCapAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -117,6 +120,7 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getLineCap().getFunction().getStops()).size()); } + @Test public void testLineJoinAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -153,6 +157,7 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getLineJoin().getFunction().getStops()).size()); } + @Test public void testLineMiterLimitAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -190,6 +195,7 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getLineMiterLimit().getFunction().getStops()).size()); } + @Test public void testLineRoundLimitAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -227,6 +233,18 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getLineRoundLimit().getFunction().getStops()).size()); } + @Test + public void testLineOpacityTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("line-opacityTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setLineOpacityTransition(options); + assertEquals(layer.getLineOpacityTransition(), options); + } + @Test public void testLineOpacityAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -372,6 +390,18 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testLineColorTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("line-colorTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setLineColorTransition(options); + assertEquals(layer.getLineColorTransition(), options); + } + @Test public void testLineColorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -494,6 +524,18 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(layer.getLineColorAsInt(), Color.RED); } + @Test + public void testLineTranslateTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("line-translateTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setLineTranslateTransition(options); + assertEquals(layer.getLineTranslateTransition(), options); + } + @Test public void testLineTranslateAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -531,6 +573,7 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getLineTranslate().getFunction().getStops()).size()); } + @Test public void testLineTranslateAnchorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -567,6 +610,18 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getLineTranslateAnchor().getFunction().getStops()).size()); } + @Test + public void testLineWidthTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("line-widthTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setLineWidthTransition(options); + assertEquals(layer.getLineWidthTransition(), options); + } + @Test public void testLineWidthAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -604,6 +659,18 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getLineWidth().getFunction().getStops()).size()); } + @Test + public void testLineGapWidthTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("line-gap-widthTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setLineGapWidthTransition(options); + assertEquals(layer.getLineGapWidthTransition(), options); + } + @Test public void testLineGapWidthAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -749,6 +816,18 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testLineOffsetTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("line-offsetTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setLineOffsetTransition(options); + assertEquals(layer.getLineOffsetTransition(), options); + } + @Test public void testLineOffsetAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -894,6 +973,18 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testLineBlurTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("line-blurTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setLineBlurTransition(options); + assertEquals(layer.getLineBlurTransition(), options); + } + @Test public void testLineBlurAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1039,6 +1130,18 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testLineDasharrayTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("line-dasharrayTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setLineDasharrayTransition(options); + assertEquals(layer.getLineDasharrayTransition(), options); + } + @Test public void testLineDasharrayAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1075,6 +1178,18 @@ public class LineLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getLineDasharray().getFunction().getStops()).size()); } + @Test + public void testLinePatternTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("line-patternTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setLinePatternTransition(options); + assertEquals(layer.getLinePatternTransition(), options); + } + @Test public void testLinePatternAsConstant() { checkViewIsDisplayed(R.id.mapView); diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/RasterLayerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/RasterLayerTest.java index eb2155f545..2d902a7432 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/RasterLayerTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/RasterLayerTest.java @@ -36,6 +36,8 @@ 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; + /** * Basic smoke tests for RasterLayer */ @@ -81,6 +83,18 @@ public class RasterLayerTest extends BaseStyleTest { assertEquals(layer.getVisibility().getValue(), NONE); } + @Test + public void testRasterOpacityTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("raster-opacityTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setRasterOpacityTransition(options); + assertEquals(layer.getRasterOpacityTransition(), options); + } + @Test public void testRasterOpacityAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -118,6 +132,18 @@ public class RasterLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getRasterOpacity().getFunction().getStops()).size()); } + @Test + public void testRasterHueRotateTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("raster-hue-rotateTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setRasterHueRotateTransition(options); + assertEquals(layer.getRasterHueRotateTransition(), options); + } + @Test public void testRasterHueRotateAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -155,6 +181,18 @@ public class RasterLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getRasterHueRotate().getFunction().getStops()).size()); } + @Test + public void testRasterBrightnessMinTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("raster-brightness-minTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setRasterBrightnessMinTransition(options); + assertEquals(layer.getRasterBrightnessMinTransition(), options); + } + @Test public void testRasterBrightnessMinAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -192,6 +230,18 @@ public class RasterLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getRasterBrightnessMin().getFunction().getStops()).size()); } + @Test + public void testRasterBrightnessMaxTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("raster-brightness-maxTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setRasterBrightnessMaxTransition(options); + assertEquals(layer.getRasterBrightnessMaxTransition(), options); + } + @Test public void testRasterBrightnessMaxAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -229,6 +279,18 @@ public class RasterLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getRasterBrightnessMax().getFunction().getStops()).size()); } + @Test + public void testRasterSaturationTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("raster-saturationTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setRasterSaturationTransition(options); + assertEquals(layer.getRasterSaturationTransition(), options); + } + @Test public void testRasterSaturationAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -266,6 +328,18 @@ public class RasterLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getRasterSaturation().getFunction().getStops()).size()); } + @Test + public void testRasterContrastTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("raster-contrastTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setRasterContrastTransition(options); + assertEquals(layer.getRasterContrastTransition(), options); + } + @Test public void testRasterContrastAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -303,6 +377,18 @@ public class RasterLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getRasterContrast().getFunction().getStops()).size()); } + @Test + public void testRasterFadeDurationTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("raster-fade-durationTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setRasterFadeDurationTransition(options); + assertEquals(layer.getRasterFadeDurationTransition(), options); + } + @Test public void testRasterFadeDurationAsConstant() { checkViewIsDisplayed(R.id.mapView); diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/SymbolLayerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/SymbolLayerTest.java index cac950dfc4..5472d32dc6 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/SymbolLayerTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/SymbolLayerTest.java @@ -36,6 +36,8 @@ 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; + /** * Basic smoke tests for SymbolLayer */ @@ -81,6 +83,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(layer.getVisibility().getValue(), NONE); } + @Test public void testSymbolPlacementAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -117,6 +120,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getSymbolPlacement().getFunction().getStops()).size()); } + @Test public void testSymbolSpacingAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -154,6 +158,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getSymbolSpacing().getFunction().getStops()).size()); } + @Test public void testSymbolAvoidEdgesAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -190,6 +195,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getSymbolAvoidEdges().getFunction().getStops()).size()); } + @Test public void testIconAllowOverlapAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -226,6 +232,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getIconAllowOverlap().getFunction().getStops()).size()); } + @Test public void testIconIgnorePlacementAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -262,6 +269,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getIconIgnorePlacement().getFunction().getStops()).size()); } + @Test public void testIconOptionalAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -298,6 +306,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getIconOptional().getFunction().getStops()).size()); } + @Test public void testIconRotationAlignmentAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -334,6 +343,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getIconRotationAlignment().getFunction().getStops()).size()); } + @Test public void testIconSizeAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -371,6 +381,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getIconSize().getFunction().getStops()).size()); } + @Test public void testIconTextFitAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -407,6 +418,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getIconTextFit().getFunction().getStops()).size()); } + @Test public void testIconTextFitPaddingAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -444,6 +456,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getIconTextFitPadding().getFunction().getStops()).size()); } + @Test public void testIconImageAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -480,6 +493,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getIconImage().getFunction().getStops()).size()); } + @Test public void testIconRotateAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -625,6 +639,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test public void testIconPaddingAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -662,6 +677,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getIconPadding().getFunction().getStops()).size()); } + @Test public void testIconKeepUprightAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -698,6 +714,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getIconKeepUpright().getFunction().getStops()).size()); } + @Test public void testIconOffsetAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -780,6 +797,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(IntervalStops.class, layer.getIconOffset().getFunction().getStops().getClass()); } + @Test public void testTextPitchAlignmentAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -816,6 +834,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getTextPitchAlignment().getFunction().getStops()).size()); } + @Test public void testTextRotationAlignmentAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -852,6 +871,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getTextRotationAlignment().getFunction().getStops()).size()); } + @Test public void testTextFieldAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -933,6 +953,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(IntervalStops.class, layer.getTextField().getFunction().getStops().getClass()); } + @Test public void testTextFontAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -969,6 +990,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getTextFont().getFunction().getStops()).size()); } + @Test public void testTextSizeAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1006,6 +1028,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getTextSize().getFunction().getStops()).size()); } + @Test public void testTextMaxWidthAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1043,6 +1066,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getTextMaxWidth().getFunction().getStops()).size()); } + @Test public void testTextLineHeightAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1080,6 +1104,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getTextLineHeight().getFunction().getStops()).size()); } + @Test public void testTextLetterSpacingAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1117,6 +1142,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getTextLetterSpacing().getFunction().getStops()).size()); } + @Test public void testTextJustifyAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1153,6 +1179,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getTextJustify().getFunction().getStops()).size()); } + @Test public void testTextAnchorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1189,6 +1216,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getTextAnchor().getFunction().getStops()).size()); } + @Test public void testTextMaxAngleAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1226,6 +1254,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getTextMaxAngle().getFunction().getStops()).size()); } + @Test public void testTextRotateAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1263,6 +1292,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getTextRotate().getFunction().getStops()).size()); } + @Test public void testTextPaddingAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1300,6 +1330,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getTextPadding().getFunction().getStops()).size()); } + @Test public void testTextKeepUprightAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1336,6 +1367,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getTextKeepUpright().getFunction().getStops()).size()); } + @Test public void testTextTransformAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1417,6 +1449,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(IntervalStops.class, layer.getTextTransform().getFunction().getStops().getClass()); } + @Test public void testTextOffsetAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1499,6 +1532,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(IntervalStops.class, layer.getTextOffset().getFunction().getStops().getClass()); } + @Test public void testTextAllowOverlapAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1535,6 +1569,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getTextAllowOverlap().getFunction().getStops()).size()); } + @Test public void testTextIgnorePlacementAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1571,6 +1606,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getTextIgnorePlacement().getFunction().getStops()).size()); } + @Test public void testTextOptionalAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1607,6 +1643,18 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getTextOptional().getFunction().getStops()).size()); } + @Test + public void testIconOpacityTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("icon-opacityTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setIconOpacityTransition(options); + assertEquals(layer.getIconOpacityTransition(), options); + } + @Test public void testIconOpacityAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1752,6 +1800,18 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testIconColorTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("icon-colorTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setIconColorTransition(options); + assertEquals(layer.getIconColorTransition(), options); + } + @Test public void testIconColorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1874,6 +1934,18 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(layer.getIconColorAsInt(), Color.RED); } + @Test + public void testIconHaloColorTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("icon-halo-colorTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setIconHaloColorTransition(options); + assertEquals(layer.getIconHaloColorTransition(), options); + } + @Test public void testIconHaloColorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -1996,6 +2068,18 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(layer.getIconHaloColorAsInt(), Color.RED); } + @Test + public void testIconHaloWidthTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("icon-halo-widthTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setIconHaloWidthTransition(options); + assertEquals(layer.getIconHaloWidthTransition(), options); + } + @Test public void testIconHaloWidthAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -2141,6 +2225,18 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testIconHaloBlurTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("icon-halo-blurTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setIconHaloBlurTransition(options); + assertEquals(layer.getIconHaloBlurTransition(), options); + } + @Test public void testIconHaloBlurAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -2286,6 +2382,18 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testIconTranslateTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("icon-translateTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setIconTranslateTransition(options); + assertEquals(layer.getIconTranslateTransition(), options); + } + @Test public void testIconTranslateAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -2323,6 +2431,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getIconTranslate().getFunction().getStops()).size()); } + @Test public void testIconTranslateAnchorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -2359,6 +2468,18 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((IntervalStops) layer.getIconTranslateAnchor().getFunction().getStops()).size()); } + @Test + public void testTextOpacityTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("text-opacityTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setTextOpacityTransition(options); + assertEquals(layer.getTextOpacityTransition(), options); + } + @Test public void testTextOpacityAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -2504,6 +2625,18 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testTextColorTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("text-colorTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setTextColorTransition(options); + assertEquals(layer.getTextColorTransition(), options); + } + @Test public void testTextColorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -2626,6 +2759,18 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(layer.getTextColorAsInt(), Color.RED); } + @Test + public void testTextHaloColorTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("text-halo-colorTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setTextHaloColorTransition(options); + assertEquals(layer.getTextHaloColorTransition(), options); + } + @Test public void testTextHaloColorAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -2748,6 +2893,18 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(layer.getTextHaloColorAsInt(), Color.RED); } + @Test + public void testTextHaloWidthTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("text-halo-widthTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setTextHaloWidthTransition(options); + assertEquals(layer.getTextHaloWidthTransition(), options); + } + @Test public void testTextHaloWidthAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -2893,6 +3050,18 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testTextHaloBlurTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("text-halo-blurTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setTextHaloBlurTransition(options); + assertEquals(layer.getTextHaloBlurTransition(), options); + } + @Test public void testTextHaloBlurAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -3038,6 +3207,18 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(0.9f, stop.out, 0.001f); } + @Test + public void testTextTranslateTransition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("text-translateTransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.setTextTranslateTransition(options); + assertEquals(layer.getTextTranslateTransition(), options); + } + @Test public void testTextTranslateAsConstant() { checkViewIsDisplayed(R.id.mapView); @@ -3075,6 +3256,7 @@ public class SymbolLayerTest extends BaseStyleTest { assertEquals(1, ((ExponentialStops) layer.getTextTranslate().getFunction().getStops()).size()); } + @Test public void testTextTranslateAnchorAsConstant() { checkViewIsDisplayed(R.id.mapView); diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/layer.junit.ejs b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/layer.junit.ejs index 3dc88d29bb..8aa0f15954 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/layer.junit.ejs +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/layer.junit.ejs @@ -40,6 +40,8 @@ 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; + /** * Basic smoke tests for <%- camelize(type) %>Layer */ @@ -91,6 +93,20 @@ public class <%- camelize(type) %>LayerTest extends BaseStyleTest { } <% for (const property of properties) { -%> +<% if (property.transition) { -%> + @Test + public void test<%- camelize(property.name) %>Transition() { + checkViewIsDisplayed(R.id.mapView); + Timber.i("<%- property.name %>TransitionOptions"); + assertNotNull(layer); + + // Set and Get + TransitionOptions options = new TransitionOptions(300, 100); + layer.set<%- camelize(property.name) %>Transition(options); + assertEquals(layer.get<%- camelize(property.name) %>Transition(), options); + } +<% } -%> + @Test public void test<%- camelize(property.name) %>AsConstant() { checkViewIsDisplayed(R.id.mapView); diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/RuntimeStyleActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/RuntimeStyleActivity.java index 2fc0407c7f..f63ede9bce 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/RuntimeStyleActivity.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/RuntimeStyleActivity.java @@ -23,6 +23,7 @@ import com.mapbox.mapboxsdk.style.layers.LineLayer; import com.mapbox.mapboxsdk.style.layers.Property; import com.mapbox.mapboxsdk.style.layers.PropertyValue; import com.mapbox.mapboxsdk.style.layers.RasterLayer; +import com.mapbox.mapboxsdk.style.layers.TransitionOptions; import com.mapbox.mapboxsdk.style.sources.GeoJsonSource; import com.mapbox.mapboxsdk.style.sources.RasterSource; import com.mapbox.mapboxsdk.style.sources.Source; @@ -95,6 +96,9 @@ public class RuntimeStyleActivity extends AppCompatActivity { // Center and Zoom (Amsterdam, zoomed to streets) mapboxMap.animateCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(52.379189, 4.899431), 14)); + + mapboxMap.setTransitionDuration(250); + mapboxMap.setTransitionDelay(50); } }); } @@ -257,10 +261,9 @@ public class RuntimeStyleActivity extends AppCompatActivity { } private void setWaterColor() { - Layer water = mapboxMap.getLayer("water"); + FillLayer water = mapboxMap.getLayerAs("water"); if (water != null) { - mapboxMap.setTransitionDuration(5000); - mapboxMap.setTransitionDelay(1000); + water.setFillColorTransition(new TransitionOptions(7500, 1000)); water.setProperties( visibility(VISIBLE), fillColor(Color.RED) @@ -510,7 +513,8 @@ public class RuntimeStyleActivity extends AppCompatActivity { if (states != null) { states.setFilter(eq("name", "Texas")); - + states.setFillOpacityTransition(new TransitionOptions(2500, 0)); + states.setFillColorTransition(new TransitionOptions(2500, 0)); states.setProperties( fillColor(Color.RED), fillOpacity(0.25f) diff --git a/platform/android/config.cmake b/platform/android/config.cmake index 1a878c984e..de8d0bacb2 100644 --- a/platform/android/config.cmake +++ b/platform/android/config.cmake @@ -119,6 +119,8 @@ add_library(mbgl-android STATIC platform/android/src/style/conversion/url_or_tileset.hpp # Style + platform/android/src/style/transition_options.cpp + platform/android/src/style/transition_options.hpp platform/android/src/style/layers/background_layer.cpp platform/android/src/style/layers/background_layer.hpp platform/android/src/style/layers/circle_layer.cpp diff --git a/platform/android/src/jni.cpp b/platform/android/src/jni.cpp index 54cb0867d0..07e0ae2f20 100755 --- a/platform/android/src/jni.cpp +++ b/platform/android/src/jni.cpp @@ -37,6 +37,7 @@ #include "offline/offline_region_definition.hpp" #include "offline/offline_region_error.hpp" #include "offline/offline_region_status.hpp" +#include "style/transition_options.hpp" #include "style/functions/categorical_stops.hpp" #include "style/functions/exponential_stops.hpp" #include "style/functions/identity_stops.hpp" @@ -149,6 +150,7 @@ void registerNatives(JavaVM *vm) { BitmapFactory::registerNative(env); // Style + TransitionOptions::registerNative(env); registerNativeLayers(env); registerNativeSources(env); Stop::registerNative(env); diff --git a/platform/android/src/style/conversion/transition_options.hpp b/platform/android/src/style/conversion/transition_options.hpp new file mode 100644 index 0000000000..3614878f43 --- /dev/null +++ b/platform/android/src/style/conversion/transition_options.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include "../../conversion/conversion.hpp" + +#include +#include "../../jni/local_object.hpp" +#include "../transition_options.hpp" + +namespace mbgl { +namespace android { +namespace conversion { + +template<> +struct Converter, mbgl::style::TransitionOptions> { + Result> operator()(jni::JNIEnv &env, const mbgl::style::TransitionOptions &value) const { + + // Convert duration + jlong duration = std::chrono::duration_cast(value.duration.value_or(mbgl::Duration::zero())).count(); + // Convert delay + jlong delay = std::chrono::duration_cast(value.delay.value_or(mbgl::Duration::zero())).count(); + + // Create transition options + return TransitionOptions::fromTransitionOptions(env, duration, delay); + } +}; + +} +} +} \ No newline at end of file diff --git a/platform/android/src/style/layers/background_layer.cpp b/platform/android/src/style/layers/background_layer.cpp index 9915f3894e..a8f013b230 100644 --- a/platform/android/src/style/layers/background_layer.cpp +++ b/platform/android/src/style/layers/background_layer.cpp @@ -5,6 +5,7 @@ #include #include "../conversion/property_value.hpp" +#include "../conversion/transition_options.hpp" namespace mbgl { namespace android { @@ -40,18 +41,58 @@ namespace android { return jni::Object(*converted); } + jni::Object BackgroundLayer::getBackgroundColorTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->BackgroundLayer::getBackgroundColorTransition(); + return *convert>(env, options); + } + + void BackgroundLayer::setBackgroundColorTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->BackgroundLayer::setBackgroundColorTransition(options); + } + jni::Object BackgroundLayer::getBackgroundPattern(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->BackgroundLayer::getBackgroundPattern()); return jni::Object(*converted); } + jni::Object BackgroundLayer::getBackgroundPatternTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->BackgroundLayer::getBackgroundPatternTransition(); + return *convert>(env, options); + } + + void BackgroundLayer::setBackgroundPatternTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->BackgroundLayer::setBackgroundPatternTransition(options); + } + jni::Object BackgroundLayer::getBackgroundOpacity(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->BackgroundLayer::getBackgroundOpacity()); return jni::Object(*converted); } + jni::Object BackgroundLayer::getBackgroundOpacityTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->BackgroundLayer::getBackgroundOpacityTransition(); + return *convert>(env, options); + } + + void BackgroundLayer::setBackgroundOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->BackgroundLayer::setBackgroundOpacityTransition(options); + } + + jni::Class BackgroundLayer::javaClass; jni::jobject* BackgroundLayer::createJavaPeer(jni::JNIEnv& env) { @@ -71,8 +112,14 @@ namespace android { std::make_unique, "initialize", "finalize", + METHOD(&BackgroundLayer::getBackgroundColorTransition, "nativeGetBackgroundColorTransition"), + METHOD(&BackgroundLayer::setBackgroundColorTransition, "nativeSetBackgroundColorTransition"), METHOD(&BackgroundLayer::getBackgroundColor, "nativeGetBackgroundColor"), + METHOD(&BackgroundLayer::getBackgroundPatternTransition, "nativeGetBackgroundPatternTransition"), + METHOD(&BackgroundLayer::setBackgroundPatternTransition, "nativeSetBackgroundPatternTransition"), METHOD(&BackgroundLayer::getBackgroundPattern, "nativeGetBackgroundPattern"), + METHOD(&BackgroundLayer::getBackgroundOpacityTransition, "nativeGetBackgroundOpacityTransition"), + METHOD(&BackgroundLayer::setBackgroundOpacityTransition, "nativeSetBackgroundOpacityTransition"), METHOD(&BackgroundLayer::getBackgroundOpacity, "nativeGetBackgroundOpacity")); } diff --git a/platform/android/src/style/layers/background_layer.hpp b/platform/android/src/style/layers/background_layer.hpp index 2fdc948892..95555a2d78 100644 --- a/platform/android/src/style/layers/background_layer.hpp +++ b/platform/android/src/style/layers/background_layer.hpp @@ -3,6 +3,7 @@ #pragma once #include "layer.hpp" +#include "../transition_options.hpp" #include #include @@ -26,13 +27,19 @@ public: ~BackgroundLayer(); - // Property getters + // Properties + jni::Object getBackgroundColor(jni::JNIEnv&); + void setBackgroundColorTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getBackgroundColorTransition(jni::JNIEnv&); jni::Object getBackgroundPattern(jni::JNIEnv&); + void setBackgroundPatternTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getBackgroundPatternTransition(jni::JNIEnv&); jni::Object getBackgroundOpacity(jni::JNIEnv&); - + void setBackgroundOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getBackgroundOpacityTransition(jni::JNIEnv&); jni::jobject* createJavaPeer(jni::JNIEnv&); }; // class BackgroundLayer diff --git a/platform/android/src/style/layers/circle_layer.cpp b/platform/android/src/style/layers/circle_layer.cpp index 948c397829..96a9356679 100644 --- a/platform/android/src/style/layers/circle_layer.cpp +++ b/platform/android/src/style/layers/circle_layer.cpp @@ -5,6 +5,7 @@ #include #include "../conversion/property_value.hpp" +#include "../conversion/transition_options.hpp" namespace mbgl { namespace android { @@ -40,30 +41,95 @@ namespace android { return jni::Object(*converted); } + jni::Object CircleLayer::getCircleRadiusTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->CircleLayer::getCircleRadiusTransition(); + return *convert>(env, options); + } + + void CircleLayer::setCircleRadiusTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->CircleLayer::setCircleRadiusTransition(options); + } + jni::Object CircleLayer::getCircleColor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->CircleLayer::getCircleColor()); return jni::Object(*converted); } + jni::Object CircleLayer::getCircleColorTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->CircleLayer::getCircleColorTransition(); + return *convert>(env, options); + } + + void CircleLayer::setCircleColorTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->CircleLayer::setCircleColorTransition(options); + } + jni::Object CircleLayer::getCircleBlur(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->CircleLayer::getCircleBlur()); return jni::Object(*converted); } + jni::Object CircleLayer::getCircleBlurTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->CircleLayer::getCircleBlurTransition(); + return *convert>(env, options); + } + + void CircleLayer::setCircleBlurTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->CircleLayer::setCircleBlurTransition(options); + } + jni::Object CircleLayer::getCircleOpacity(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->CircleLayer::getCircleOpacity()); return jni::Object(*converted); } + jni::Object CircleLayer::getCircleOpacityTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->CircleLayer::getCircleOpacityTransition(); + return *convert>(env, options); + } + + void CircleLayer::setCircleOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->CircleLayer::setCircleOpacityTransition(options); + } + jni::Object CircleLayer::getCircleTranslate(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->CircleLayer::getCircleTranslate()); return jni::Object(*converted); } + jni::Object CircleLayer::getCircleTranslateTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->CircleLayer::getCircleTranslateTransition(); + return *convert>(env, options); + } + + void CircleLayer::setCircleTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->CircleLayer::setCircleTranslateTransition(options); + } + jni::Object CircleLayer::getCircleTranslateAnchor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->CircleLayer::getCircleTranslateAnchor()); @@ -82,18 +148,58 @@ namespace android { return jni::Object(*converted); } + jni::Object CircleLayer::getCircleStrokeWidthTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->CircleLayer::getCircleStrokeWidthTransition(); + return *convert>(env, options); + } + + void CircleLayer::setCircleStrokeWidthTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->CircleLayer::setCircleStrokeWidthTransition(options); + } + jni::Object CircleLayer::getCircleStrokeColor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->CircleLayer::getCircleStrokeColor()); return jni::Object(*converted); } + jni::Object CircleLayer::getCircleStrokeColorTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->CircleLayer::getCircleStrokeColorTransition(); + return *convert>(env, options); + } + + void CircleLayer::setCircleStrokeColorTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->CircleLayer::setCircleStrokeColorTransition(options); + } + jni::Object CircleLayer::getCircleStrokeOpacity(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->CircleLayer::getCircleStrokeOpacity()); return jni::Object(*converted); } + jni::Object CircleLayer::getCircleStrokeOpacityTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->CircleLayer::getCircleStrokeOpacityTransition(); + return *convert>(env, options); + } + + void CircleLayer::setCircleStrokeOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->CircleLayer::setCircleStrokeOpacityTransition(options); + } + + jni::Class CircleLayer::javaClass; jni::jobject* CircleLayer::createJavaPeer(jni::JNIEnv& env) { @@ -113,15 +219,31 @@ namespace android { std::make_unique, "initialize", "finalize", + METHOD(&CircleLayer::getCircleRadiusTransition, "nativeGetCircleRadiusTransition"), + METHOD(&CircleLayer::setCircleRadiusTransition, "nativeSetCircleRadiusTransition"), METHOD(&CircleLayer::getCircleRadius, "nativeGetCircleRadius"), + METHOD(&CircleLayer::getCircleColorTransition, "nativeGetCircleColorTransition"), + METHOD(&CircleLayer::setCircleColorTransition, "nativeSetCircleColorTransition"), METHOD(&CircleLayer::getCircleColor, "nativeGetCircleColor"), + METHOD(&CircleLayer::getCircleBlurTransition, "nativeGetCircleBlurTransition"), + METHOD(&CircleLayer::setCircleBlurTransition, "nativeSetCircleBlurTransition"), METHOD(&CircleLayer::getCircleBlur, "nativeGetCircleBlur"), + METHOD(&CircleLayer::getCircleOpacityTransition, "nativeGetCircleOpacityTransition"), + METHOD(&CircleLayer::setCircleOpacityTransition, "nativeSetCircleOpacityTransition"), METHOD(&CircleLayer::getCircleOpacity, "nativeGetCircleOpacity"), + METHOD(&CircleLayer::getCircleTranslateTransition, "nativeGetCircleTranslateTransition"), + METHOD(&CircleLayer::setCircleTranslateTransition, "nativeSetCircleTranslateTransition"), METHOD(&CircleLayer::getCircleTranslate, "nativeGetCircleTranslate"), METHOD(&CircleLayer::getCircleTranslateAnchor, "nativeGetCircleTranslateAnchor"), METHOD(&CircleLayer::getCirclePitchScale, "nativeGetCirclePitchScale"), + METHOD(&CircleLayer::getCircleStrokeWidthTransition, "nativeGetCircleStrokeWidthTransition"), + METHOD(&CircleLayer::setCircleStrokeWidthTransition, "nativeSetCircleStrokeWidthTransition"), METHOD(&CircleLayer::getCircleStrokeWidth, "nativeGetCircleStrokeWidth"), + METHOD(&CircleLayer::getCircleStrokeColorTransition, "nativeGetCircleStrokeColorTransition"), + METHOD(&CircleLayer::setCircleStrokeColorTransition, "nativeSetCircleStrokeColorTransition"), METHOD(&CircleLayer::getCircleStrokeColor, "nativeGetCircleStrokeColor"), + METHOD(&CircleLayer::getCircleStrokeOpacityTransition, "nativeGetCircleStrokeOpacityTransition"), + METHOD(&CircleLayer::setCircleStrokeOpacityTransition, "nativeSetCircleStrokeOpacityTransition"), METHOD(&CircleLayer::getCircleStrokeOpacity, "nativeGetCircleStrokeOpacity")); } diff --git a/platform/android/src/style/layers/circle_layer.hpp b/platform/android/src/style/layers/circle_layer.hpp index ee988d7c57..81737e8996 100644 --- a/platform/android/src/style/layers/circle_layer.hpp +++ b/platform/android/src/style/layers/circle_layer.hpp @@ -3,6 +3,7 @@ #pragma once #include "layer.hpp" +#include "../transition_options.hpp" #include #include @@ -26,27 +27,43 @@ public: ~CircleLayer(); - // Property getters + // Properties + jni::Object getCircleRadius(jni::JNIEnv&); + void setCircleRadiusTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getCircleRadiusTransition(jni::JNIEnv&); jni::Object getCircleColor(jni::JNIEnv&); + void setCircleColorTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getCircleColorTransition(jni::JNIEnv&); jni::Object getCircleBlur(jni::JNIEnv&); + void setCircleBlurTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getCircleBlurTransition(jni::JNIEnv&); jni::Object getCircleOpacity(jni::JNIEnv&); + void setCircleOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getCircleOpacityTransition(jni::JNIEnv&); jni::Object getCircleTranslate(jni::JNIEnv&); + void setCircleTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getCircleTranslateTransition(jni::JNIEnv&); jni::Object getCircleTranslateAnchor(jni::JNIEnv&); jni::Object getCirclePitchScale(jni::JNIEnv&); jni::Object getCircleStrokeWidth(jni::JNIEnv&); + void setCircleStrokeWidthTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getCircleStrokeWidthTransition(jni::JNIEnv&); jni::Object getCircleStrokeColor(jni::JNIEnv&); + void setCircleStrokeColorTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getCircleStrokeColorTransition(jni::JNIEnv&); jni::Object getCircleStrokeOpacity(jni::JNIEnv&); - + void setCircleStrokeOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getCircleStrokeOpacityTransition(jni::JNIEnv&); jni::jobject* createJavaPeer(jni::JNIEnv&); }; // class CircleLayer diff --git a/platform/android/src/style/layers/fill_layer.cpp b/platform/android/src/style/layers/fill_layer.cpp index fc1dfccfcc..f4cddc8858 100644 --- a/platform/android/src/style/layers/fill_layer.cpp +++ b/platform/android/src/style/layers/fill_layer.cpp @@ -5,6 +5,7 @@ #include #include "../conversion/property_value.hpp" +#include "../conversion/transition_options.hpp" namespace mbgl { namespace android { @@ -46,24 +47,76 @@ namespace android { return jni::Object(*converted); } + jni::Object FillLayer::getFillOpacityTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->FillLayer::getFillOpacityTransition(); + return *convert>(env, options); + } + + void FillLayer::setFillOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->FillLayer::setFillOpacityTransition(options); + } + jni::Object FillLayer::getFillColor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->FillLayer::getFillColor()); return jni::Object(*converted); } + jni::Object FillLayer::getFillColorTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->FillLayer::getFillColorTransition(); + return *convert>(env, options); + } + + void FillLayer::setFillColorTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->FillLayer::setFillColorTransition(options); + } + jni::Object FillLayer::getFillOutlineColor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->FillLayer::getFillOutlineColor()); return jni::Object(*converted); } + jni::Object FillLayer::getFillOutlineColorTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->FillLayer::getFillOutlineColorTransition(); + return *convert>(env, options); + } + + void FillLayer::setFillOutlineColorTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->FillLayer::setFillOutlineColorTransition(options); + } + jni::Object FillLayer::getFillTranslate(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->FillLayer::getFillTranslate()); return jni::Object(*converted); } + jni::Object FillLayer::getFillTranslateTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->FillLayer::getFillTranslateTransition(); + return *convert>(env, options); + } + + void FillLayer::setFillTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->FillLayer::setFillTranslateTransition(options); + } + jni::Object FillLayer::getFillTranslateAnchor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->FillLayer::getFillTranslateAnchor()); @@ -76,6 +129,20 @@ namespace android { return jni::Object(*converted); } + jni::Object FillLayer::getFillPatternTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->FillLayer::getFillPatternTransition(); + return *convert>(env, options); + } + + void FillLayer::setFillPatternTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->FillLayer::setFillPatternTransition(options); + } + + jni::Class FillLayer::javaClass; jni::jobject* FillLayer::createJavaPeer(jni::JNIEnv& env) { @@ -96,11 +163,21 @@ namespace android { "initialize", "finalize", METHOD(&FillLayer::getFillAntialias, "nativeGetFillAntialias"), + METHOD(&FillLayer::getFillOpacityTransition, "nativeGetFillOpacityTransition"), + METHOD(&FillLayer::setFillOpacityTransition, "nativeSetFillOpacityTransition"), METHOD(&FillLayer::getFillOpacity, "nativeGetFillOpacity"), + METHOD(&FillLayer::getFillColorTransition, "nativeGetFillColorTransition"), + METHOD(&FillLayer::setFillColorTransition, "nativeSetFillColorTransition"), METHOD(&FillLayer::getFillColor, "nativeGetFillColor"), + METHOD(&FillLayer::getFillOutlineColorTransition, "nativeGetFillOutlineColorTransition"), + METHOD(&FillLayer::setFillOutlineColorTransition, "nativeSetFillOutlineColorTransition"), METHOD(&FillLayer::getFillOutlineColor, "nativeGetFillOutlineColor"), + METHOD(&FillLayer::getFillTranslateTransition, "nativeGetFillTranslateTransition"), + METHOD(&FillLayer::setFillTranslateTransition, "nativeSetFillTranslateTransition"), METHOD(&FillLayer::getFillTranslate, "nativeGetFillTranslate"), METHOD(&FillLayer::getFillTranslateAnchor, "nativeGetFillTranslateAnchor"), + METHOD(&FillLayer::getFillPatternTransition, "nativeGetFillPatternTransition"), + METHOD(&FillLayer::setFillPatternTransition, "nativeSetFillPatternTransition"), METHOD(&FillLayer::getFillPattern, "nativeGetFillPattern")); } diff --git a/platform/android/src/style/layers/fill_layer.hpp b/platform/android/src/style/layers/fill_layer.hpp index f43c263ab8..a773cf785b 100644 --- a/platform/android/src/style/layers/fill_layer.hpp +++ b/platform/android/src/style/layers/fill_layer.hpp @@ -3,6 +3,7 @@ #pragma once #include "layer.hpp" +#include "../transition_options.hpp" #include #include @@ -26,21 +27,31 @@ public: ~FillLayer(); - // Property getters + // Properties + jni::Object getFillAntialias(jni::JNIEnv&); jni::Object getFillOpacity(jni::JNIEnv&); + void setFillOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getFillOpacityTransition(jni::JNIEnv&); jni::Object getFillColor(jni::JNIEnv&); + void setFillColorTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getFillColorTransition(jni::JNIEnv&); jni::Object getFillOutlineColor(jni::JNIEnv&); + void setFillOutlineColorTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getFillOutlineColorTransition(jni::JNIEnv&); jni::Object getFillTranslate(jni::JNIEnv&); + void setFillTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getFillTranslateTransition(jni::JNIEnv&); jni::Object getFillTranslateAnchor(jni::JNIEnv&); jni::Object getFillPattern(jni::JNIEnv&); - + void setFillPatternTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getFillPatternTransition(jni::JNIEnv&); jni::jobject* createJavaPeer(jni::JNIEnv&); }; // class FillLayer diff --git a/platform/android/src/style/layers/layer.cpp b/platform/android/src/style/layers/layer.cpp index 6e93cf4daf..6c9de51a0d 100644 --- a/platform/android/src/style/layers/layer.cpp +++ b/platform/android/src/style/layers/layer.cpp @@ -3,6 +3,7 @@ #include +#include #include // Java -> C++ conversion diff --git a/platform/android/src/style/layers/layer.cpp.ejs b/platform/android/src/style/layers/layer.cpp.ejs index 5da397d77d..1debb096a3 100644 --- a/platform/android/src/style/layers/layer.cpp.ejs +++ b/platform/android/src/style/layers/layer.cpp.ejs @@ -9,6 +9,7 @@ #include #include "../conversion/property_value.hpp" +#include "../conversion/transition_options.hpp" namespace mbgl { namespace android { @@ -53,7 +54,23 @@ namespace android { return jni::Object(*converted); } +<% if (property.transition) { -%> + jni::Object <%- camelize(type) %>Layer::get<%- camelize(property.name) %>Transition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.asLayer>()-><%- camelize(type) %>Layer::get<%- camelize(property.name) %>Transition(); + return *convert>(env, options); + } + + void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>Transition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.asLayer>()-><%- camelize(type) %>Layer::set<%- camelize(property.name) %>Transition(options); + } + +<% } -%> <% } -%> + jni::Class<<%- camelize(type) %>Layer> <%- camelize(type) %>Layer::javaClass; jni::jobject* <%- camelize(type) %>Layer::createJavaPeer(jni::JNIEnv& env) { @@ -77,8 +94,11 @@ namespace android { <% } -%> "initialize", "finalize",<% for(var i = 0; i < properties.length; i++) {%> - METHOD(&<%- camelize(type) %>Layer::get<%- camelize(properties[i].name) %>, "nativeGet<%- camelize(properties[i].name) %>")<% if(i != (properties.length -1)) {-%>,<% } -%> -<% } -%>); +<% if (properties[i].transition) { -%> + METHOD(&<%- camelize(type) %>Layer::get<%- camelize(properties[i].name) %>Transition, "nativeGet<%- camelize(properties[i].name) %>Transition"), + METHOD(&<%- camelize(type) %>Layer::set<%- camelize(properties[i].name) %>Transition, "nativeSet<%- camelize(properties[i].name) %>Transition"), +<% } -%> + METHOD(&<%- camelize(type) %>Layer::get<%- camelize(properties[i].name) %>, "nativeGet<%- camelize(properties[i].name) %>")<% if(i != (properties.length -1)) {-%>,<% } -%><% } -%>); } } // namespace android diff --git a/platform/android/src/style/layers/layer.hpp.ejs b/platform/android/src/style/layers/layer.hpp.ejs index 102efd2d4d..d1e84ac2d4 100644 --- a/platform/android/src/style/layers/layer.hpp.ejs +++ b/platform/android/src/style/layers/layer.hpp.ejs @@ -7,6 +7,7 @@ #pragma once #include "layer.hpp" +#include "../transition_options.hpp" #include _layer.hpp> #include @@ -34,11 +35,16 @@ public: ~<%- camelize(type) %>Layer(); - // Property getters + // Properties <% for (const property of properties) { -%> - jni::Object get<%- camelize(property.name) %>(jni::JNIEnv&); + jni::Object get<%- camelize(property.name) %>(jni::JNIEnv&); +<% if (property.transition) { -%> + void set<%- camelize(property.name) %>Transition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object get<%- camelize(property.name) %>Transition(jni::JNIEnv&); <% } -%> +<% } -%> + jni::jobject* createJavaPeer(jni::JNIEnv&); }; // class <%- camelize(type) %>Layer diff --git a/platform/android/src/style/layers/line_layer.cpp b/platform/android/src/style/layers/line_layer.cpp index 1a3a666a7b..af4e24523e 100644 --- a/platform/android/src/style/layers/line_layer.cpp +++ b/platform/android/src/style/layers/line_layer.cpp @@ -5,6 +5,7 @@ #include #include "../conversion/property_value.hpp" +#include "../conversion/transition_options.hpp" namespace mbgl { namespace android { @@ -64,18 +65,57 @@ namespace android { return jni::Object(*converted); } + jni::Object LineLayer::getLineOpacityTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->LineLayer::getLineOpacityTransition(); + return *convert>(env, options); + } + + void LineLayer::setLineOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->LineLayer::setLineOpacityTransition(options); + } + jni::Object LineLayer::getLineColor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->LineLayer::getLineColor()); return jni::Object(*converted); } + jni::Object LineLayer::getLineColorTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->LineLayer::getLineColorTransition(); + return *convert>(env, options); + } + + void LineLayer::setLineColorTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->LineLayer::setLineColorTransition(options); + } + jni::Object LineLayer::getLineTranslate(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->LineLayer::getLineTranslate()); return jni::Object(*converted); } + jni::Object LineLayer::getLineTranslateTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->LineLayer::getLineTranslateTransition(); + return *convert>(env, options); + } + + void LineLayer::setLineTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->LineLayer::setLineTranslateTransition(options); + } + jni::Object LineLayer::getLineTranslateAnchor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->LineLayer::getLineTranslateAnchor()); @@ -88,36 +128,115 @@ namespace android { return jni::Object(*converted); } + jni::Object LineLayer::getLineWidthTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->LineLayer::getLineWidthTransition(); + return *convert>(env, options); + } + + void LineLayer::setLineWidthTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->LineLayer::setLineWidthTransition(options); + } + jni::Object LineLayer::getLineGapWidth(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->LineLayer::getLineGapWidth()); return jni::Object(*converted); } + jni::Object LineLayer::getLineGapWidthTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->LineLayer::getLineGapWidthTransition(); + return *convert>(env, options); + } + + void LineLayer::setLineGapWidthTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->LineLayer::setLineGapWidthTransition(options); + } + jni::Object LineLayer::getLineOffset(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->LineLayer::getLineOffset()); return jni::Object(*converted); } + jni::Object LineLayer::getLineOffsetTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->LineLayer::getLineOffsetTransition(); + return *convert>(env, options); + } + + void LineLayer::setLineOffsetTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->LineLayer::setLineOffsetTransition(options); + } + jni::Object LineLayer::getLineBlur(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->LineLayer::getLineBlur()); return jni::Object(*converted); } + jni::Object LineLayer::getLineBlurTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->LineLayer::getLineBlurTransition(); + return *convert>(env, options); + } + + void LineLayer::setLineBlurTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->LineLayer::setLineBlurTransition(options); + } + jni::Object LineLayer::getLineDasharray(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->LineLayer::getLineDasharray()); return jni::Object(*converted); } + jni::Object LineLayer::getLineDasharrayTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->LineLayer::getLineDasharrayTransition(); + return *convert>(env, options); + } + + void LineLayer::setLineDasharrayTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->LineLayer::setLineDasharrayTransition(options); + } + jni::Object LineLayer::getLinePattern(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->LineLayer::getLinePattern()); return jni::Object(*converted); } + jni::Object LineLayer::getLinePatternTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->LineLayer::getLinePatternTransition(); + return *convert>(env, options); + } + + void LineLayer::setLinePatternTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->LineLayer::setLinePatternTransition(options); + } + + jni::Class LineLayer::javaClass; jni::jobject* LineLayer::createJavaPeer(jni::JNIEnv& env) { @@ -141,15 +260,33 @@ namespace android { METHOD(&LineLayer::getLineJoin, "nativeGetLineJoin"), METHOD(&LineLayer::getLineMiterLimit, "nativeGetLineMiterLimit"), METHOD(&LineLayer::getLineRoundLimit, "nativeGetLineRoundLimit"), + METHOD(&LineLayer::getLineOpacityTransition, "nativeGetLineOpacityTransition"), + METHOD(&LineLayer::setLineOpacityTransition, "nativeSetLineOpacityTransition"), METHOD(&LineLayer::getLineOpacity, "nativeGetLineOpacity"), + METHOD(&LineLayer::getLineColorTransition, "nativeGetLineColorTransition"), + METHOD(&LineLayer::setLineColorTransition, "nativeSetLineColorTransition"), METHOD(&LineLayer::getLineColor, "nativeGetLineColor"), + METHOD(&LineLayer::getLineTranslateTransition, "nativeGetLineTranslateTransition"), + METHOD(&LineLayer::setLineTranslateTransition, "nativeSetLineTranslateTransition"), METHOD(&LineLayer::getLineTranslate, "nativeGetLineTranslate"), METHOD(&LineLayer::getLineTranslateAnchor, "nativeGetLineTranslateAnchor"), + METHOD(&LineLayer::getLineWidthTransition, "nativeGetLineWidthTransition"), + METHOD(&LineLayer::setLineWidthTransition, "nativeSetLineWidthTransition"), METHOD(&LineLayer::getLineWidth, "nativeGetLineWidth"), + METHOD(&LineLayer::getLineGapWidthTransition, "nativeGetLineGapWidthTransition"), + METHOD(&LineLayer::setLineGapWidthTransition, "nativeSetLineGapWidthTransition"), METHOD(&LineLayer::getLineGapWidth, "nativeGetLineGapWidth"), + METHOD(&LineLayer::getLineOffsetTransition, "nativeGetLineOffsetTransition"), + METHOD(&LineLayer::setLineOffsetTransition, "nativeSetLineOffsetTransition"), METHOD(&LineLayer::getLineOffset, "nativeGetLineOffset"), + METHOD(&LineLayer::getLineBlurTransition, "nativeGetLineBlurTransition"), + METHOD(&LineLayer::setLineBlurTransition, "nativeSetLineBlurTransition"), METHOD(&LineLayer::getLineBlur, "nativeGetLineBlur"), + METHOD(&LineLayer::getLineDasharrayTransition, "nativeGetLineDasharrayTransition"), + METHOD(&LineLayer::setLineDasharrayTransition, "nativeSetLineDasharrayTransition"), METHOD(&LineLayer::getLineDasharray, "nativeGetLineDasharray"), + METHOD(&LineLayer::getLinePatternTransition, "nativeGetLinePatternTransition"), + METHOD(&LineLayer::setLinePatternTransition, "nativeSetLinePatternTransition"), METHOD(&LineLayer::getLinePattern, "nativeGetLinePattern")); } diff --git a/platform/android/src/style/layers/line_layer.hpp b/platform/android/src/style/layers/line_layer.hpp index a79c8b9021..84ecc77139 100644 --- a/platform/android/src/style/layers/line_layer.hpp +++ b/platform/android/src/style/layers/line_layer.hpp @@ -3,6 +3,7 @@ #pragma once #include "layer.hpp" +#include "../transition_options.hpp" #include #include @@ -26,7 +27,8 @@ public: ~LineLayer(); - // Property getters + // Properties + jni::Object getLineCap(jni::JNIEnv&); jni::Object getLineJoin(jni::JNIEnv&); @@ -36,25 +38,42 @@ public: jni::Object getLineRoundLimit(jni::JNIEnv&); jni::Object getLineOpacity(jni::JNIEnv&); + void setLineOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getLineOpacityTransition(jni::JNIEnv&); jni::Object getLineColor(jni::JNIEnv&); + void setLineColorTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getLineColorTransition(jni::JNIEnv&); jni::Object getLineTranslate(jni::JNIEnv&); + void setLineTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getLineTranslateTransition(jni::JNIEnv&); jni::Object getLineTranslateAnchor(jni::JNIEnv&); jni::Object getLineWidth(jni::JNIEnv&); + void setLineWidthTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getLineWidthTransition(jni::JNIEnv&); jni::Object getLineGapWidth(jni::JNIEnv&); + void setLineGapWidthTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getLineGapWidthTransition(jni::JNIEnv&); jni::Object getLineOffset(jni::JNIEnv&); + void setLineOffsetTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getLineOffsetTransition(jni::JNIEnv&); jni::Object getLineBlur(jni::JNIEnv&); + void setLineBlurTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getLineBlurTransition(jni::JNIEnv&); jni::Object getLineDasharray(jni::JNIEnv&); + void setLineDasharrayTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getLineDasharrayTransition(jni::JNIEnv&); jni::Object getLinePattern(jni::JNIEnv&); - + void setLinePatternTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getLinePatternTransition(jni::JNIEnv&); jni::jobject* createJavaPeer(jni::JNIEnv&); }; // class LineLayer diff --git a/platform/android/src/style/layers/raster_layer.cpp b/platform/android/src/style/layers/raster_layer.cpp index 8a324b88f2..98923d5129 100644 --- a/platform/android/src/style/layers/raster_layer.cpp +++ b/platform/android/src/style/layers/raster_layer.cpp @@ -5,6 +5,7 @@ #include #include "../conversion/property_value.hpp" +#include "../conversion/transition_options.hpp" namespace mbgl { namespace android { @@ -40,42 +41,134 @@ namespace android { return jni::Object(*converted); } + jni::Object RasterLayer::getRasterOpacityTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->RasterLayer::getRasterOpacityTransition(); + return *convert>(env, options); + } + + void RasterLayer::setRasterOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->RasterLayer::setRasterOpacityTransition(options); + } + jni::Object RasterLayer::getRasterHueRotate(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->RasterLayer::getRasterHueRotate()); return jni::Object(*converted); } + jni::Object RasterLayer::getRasterHueRotateTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->RasterLayer::getRasterHueRotateTransition(); + return *convert>(env, options); + } + + void RasterLayer::setRasterHueRotateTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->RasterLayer::setRasterHueRotateTransition(options); + } + jni::Object RasterLayer::getRasterBrightnessMin(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->RasterLayer::getRasterBrightnessMin()); return jni::Object(*converted); } + jni::Object RasterLayer::getRasterBrightnessMinTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->RasterLayer::getRasterBrightnessMinTransition(); + return *convert>(env, options); + } + + void RasterLayer::setRasterBrightnessMinTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->RasterLayer::setRasterBrightnessMinTransition(options); + } + jni::Object RasterLayer::getRasterBrightnessMax(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->RasterLayer::getRasterBrightnessMax()); return jni::Object(*converted); } + jni::Object RasterLayer::getRasterBrightnessMaxTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->RasterLayer::getRasterBrightnessMaxTransition(); + return *convert>(env, options); + } + + void RasterLayer::setRasterBrightnessMaxTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->RasterLayer::setRasterBrightnessMaxTransition(options); + } + jni::Object RasterLayer::getRasterSaturation(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->RasterLayer::getRasterSaturation()); return jni::Object(*converted); } + jni::Object RasterLayer::getRasterSaturationTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->RasterLayer::getRasterSaturationTransition(); + return *convert>(env, options); + } + + void RasterLayer::setRasterSaturationTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->RasterLayer::setRasterSaturationTransition(options); + } + jni::Object RasterLayer::getRasterContrast(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->RasterLayer::getRasterContrast()); return jni::Object(*converted); } + jni::Object RasterLayer::getRasterContrastTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->RasterLayer::getRasterContrastTransition(); + return *convert>(env, options); + } + + void RasterLayer::setRasterContrastTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->RasterLayer::setRasterContrastTransition(options); + } + jni::Object RasterLayer::getRasterFadeDuration(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->RasterLayer::getRasterFadeDuration()); return jni::Object(*converted); } + jni::Object RasterLayer::getRasterFadeDurationTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->RasterLayer::getRasterFadeDurationTransition(); + return *convert>(env, options); + } + + void RasterLayer::setRasterFadeDurationTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->RasterLayer::setRasterFadeDurationTransition(options); + } + + jni::Class RasterLayer::javaClass; jni::jobject* RasterLayer::createJavaPeer(jni::JNIEnv& env) { @@ -95,12 +188,26 @@ namespace android { std::make_unique, "initialize", "finalize", + METHOD(&RasterLayer::getRasterOpacityTransition, "nativeGetRasterOpacityTransition"), + METHOD(&RasterLayer::setRasterOpacityTransition, "nativeSetRasterOpacityTransition"), METHOD(&RasterLayer::getRasterOpacity, "nativeGetRasterOpacity"), + METHOD(&RasterLayer::getRasterHueRotateTransition, "nativeGetRasterHueRotateTransition"), + METHOD(&RasterLayer::setRasterHueRotateTransition, "nativeSetRasterHueRotateTransition"), METHOD(&RasterLayer::getRasterHueRotate, "nativeGetRasterHueRotate"), + METHOD(&RasterLayer::getRasterBrightnessMinTransition, "nativeGetRasterBrightnessMinTransition"), + METHOD(&RasterLayer::setRasterBrightnessMinTransition, "nativeSetRasterBrightnessMinTransition"), METHOD(&RasterLayer::getRasterBrightnessMin, "nativeGetRasterBrightnessMin"), + METHOD(&RasterLayer::getRasterBrightnessMaxTransition, "nativeGetRasterBrightnessMaxTransition"), + METHOD(&RasterLayer::setRasterBrightnessMaxTransition, "nativeSetRasterBrightnessMaxTransition"), METHOD(&RasterLayer::getRasterBrightnessMax, "nativeGetRasterBrightnessMax"), + METHOD(&RasterLayer::getRasterSaturationTransition, "nativeGetRasterSaturationTransition"), + METHOD(&RasterLayer::setRasterSaturationTransition, "nativeSetRasterSaturationTransition"), METHOD(&RasterLayer::getRasterSaturation, "nativeGetRasterSaturation"), + METHOD(&RasterLayer::getRasterContrastTransition, "nativeGetRasterContrastTransition"), + METHOD(&RasterLayer::setRasterContrastTransition, "nativeSetRasterContrastTransition"), METHOD(&RasterLayer::getRasterContrast, "nativeGetRasterContrast"), + METHOD(&RasterLayer::getRasterFadeDurationTransition, "nativeGetRasterFadeDurationTransition"), + METHOD(&RasterLayer::setRasterFadeDurationTransition, "nativeSetRasterFadeDurationTransition"), METHOD(&RasterLayer::getRasterFadeDuration, "nativeGetRasterFadeDuration")); } diff --git a/platform/android/src/style/layers/raster_layer.hpp b/platform/android/src/style/layers/raster_layer.hpp index 2f5d4f6fcd..3b119ee0d2 100644 --- a/platform/android/src/style/layers/raster_layer.hpp +++ b/platform/android/src/style/layers/raster_layer.hpp @@ -3,6 +3,7 @@ #pragma once #include "layer.hpp" +#include "../transition_options.hpp" #include #include @@ -26,21 +27,35 @@ public: ~RasterLayer(); - // Property getters + // Properties + jni::Object getRasterOpacity(jni::JNIEnv&); + void setRasterOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getRasterOpacityTransition(jni::JNIEnv&); jni::Object getRasterHueRotate(jni::JNIEnv&); + void setRasterHueRotateTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getRasterHueRotateTransition(jni::JNIEnv&); jni::Object getRasterBrightnessMin(jni::JNIEnv&); + void setRasterBrightnessMinTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getRasterBrightnessMinTransition(jni::JNIEnv&); jni::Object getRasterBrightnessMax(jni::JNIEnv&); + void setRasterBrightnessMaxTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getRasterBrightnessMaxTransition(jni::JNIEnv&); jni::Object getRasterSaturation(jni::JNIEnv&); + void setRasterSaturationTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getRasterSaturationTransition(jni::JNIEnv&); jni::Object getRasterContrast(jni::JNIEnv&); + void setRasterContrastTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getRasterContrastTransition(jni::JNIEnv&); jni::Object getRasterFadeDuration(jni::JNIEnv&); - + void setRasterFadeDurationTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getRasterFadeDurationTransition(jni::JNIEnv&); jni::jobject* createJavaPeer(jni::JNIEnv&); }; // class RasterLayer diff --git a/platform/android/src/style/layers/symbol_layer.cpp b/platform/android/src/style/layers/symbol_layer.cpp index e42eeb4c77..3a560a5deb 100644 --- a/platform/android/src/style/layers/symbol_layer.cpp +++ b/platform/android/src/style/layers/symbol_layer.cpp @@ -5,6 +5,7 @@ #include #include "../conversion/property_value.hpp" +#include "../conversion/transition_options.hpp" namespace mbgl { namespace android { @@ -244,36 +245,114 @@ namespace android { return jni::Object(*converted); } + jni::Object SymbolLayer::getIconOpacityTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->SymbolLayer::getIconOpacityTransition(); + return *convert>(env, options); + } + + void SymbolLayer::setIconOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->SymbolLayer::setIconOpacityTransition(options); + } + jni::Object SymbolLayer::getIconColor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->SymbolLayer::getIconColor()); return jni::Object(*converted); } + jni::Object SymbolLayer::getIconColorTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->SymbolLayer::getIconColorTransition(); + return *convert>(env, options); + } + + void SymbolLayer::setIconColorTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->SymbolLayer::setIconColorTransition(options); + } + jni::Object SymbolLayer::getIconHaloColor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->SymbolLayer::getIconHaloColor()); return jni::Object(*converted); } + jni::Object SymbolLayer::getIconHaloColorTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->SymbolLayer::getIconHaloColorTransition(); + return *convert>(env, options); + } + + void SymbolLayer::setIconHaloColorTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->SymbolLayer::setIconHaloColorTransition(options); + } + jni::Object SymbolLayer::getIconHaloWidth(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->SymbolLayer::getIconHaloWidth()); return jni::Object(*converted); } + jni::Object SymbolLayer::getIconHaloWidthTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->SymbolLayer::getIconHaloWidthTransition(); + return *convert>(env, options); + } + + void SymbolLayer::setIconHaloWidthTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->SymbolLayer::setIconHaloWidthTransition(options); + } + jni::Object SymbolLayer::getIconHaloBlur(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->SymbolLayer::getIconHaloBlur()); return jni::Object(*converted); } + jni::Object SymbolLayer::getIconHaloBlurTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->SymbolLayer::getIconHaloBlurTransition(); + return *convert>(env, options); + } + + void SymbolLayer::setIconHaloBlurTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->SymbolLayer::setIconHaloBlurTransition(options); + } + jni::Object SymbolLayer::getIconTranslate(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->SymbolLayer::getIconTranslate()); return jni::Object(*converted); } + jni::Object SymbolLayer::getIconTranslateTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->SymbolLayer::getIconTranslateTransition(); + return *convert>(env, options); + } + + void SymbolLayer::setIconTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->SymbolLayer::setIconTranslateTransition(options); + } + jni::Object SymbolLayer::getIconTranslateAnchor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->SymbolLayer::getIconTranslateAnchor()); @@ -286,42 +365,121 @@ namespace android { return jni::Object(*converted); } + jni::Object SymbolLayer::getTextOpacityTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->SymbolLayer::getTextOpacityTransition(); + return *convert>(env, options); + } + + void SymbolLayer::setTextOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->SymbolLayer::setTextOpacityTransition(options); + } + jni::Object SymbolLayer::getTextColor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->SymbolLayer::getTextColor()); return jni::Object(*converted); } + jni::Object SymbolLayer::getTextColorTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->SymbolLayer::getTextColorTransition(); + return *convert>(env, options); + } + + void SymbolLayer::setTextColorTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->SymbolLayer::setTextColorTransition(options); + } + jni::Object SymbolLayer::getTextHaloColor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->SymbolLayer::getTextHaloColor()); return jni::Object(*converted); } + jni::Object SymbolLayer::getTextHaloColorTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->SymbolLayer::getTextHaloColorTransition(); + return *convert>(env, options); + } + + void SymbolLayer::setTextHaloColorTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->SymbolLayer::setTextHaloColorTransition(options); + } + jni::Object SymbolLayer::getTextHaloWidth(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->SymbolLayer::getTextHaloWidth()); return jni::Object(*converted); } + jni::Object SymbolLayer::getTextHaloWidthTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->SymbolLayer::getTextHaloWidthTransition(); + return *convert>(env, options); + } + + void SymbolLayer::setTextHaloWidthTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->SymbolLayer::setTextHaloWidthTransition(options); + } + jni::Object SymbolLayer::getTextHaloBlur(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->SymbolLayer::getTextHaloBlur()); return jni::Object(*converted); } + jni::Object SymbolLayer::getTextHaloBlurTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->SymbolLayer::getTextHaloBlurTransition(); + return *convert>(env, options); + } + + void SymbolLayer::setTextHaloBlurTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->SymbolLayer::setTextHaloBlurTransition(options); + } + jni::Object SymbolLayer::getTextTranslate(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->SymbolLayer::getTextTranslate()); return jni::Object(*converted); } + jni::Object SymbolLayer::getTextTranslateTransition(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + mbgl::style::TransitionOptions options = layer.as()->SymbolLayer::getTextTranslateTransition(); + return *convert>(env, options); + } + + void SymbolLayer::setTextTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) { + mbgl::style::TransitionOptions options; + options.duration.emplace(mbgl::Milliseconds(duration)); + options.delay.emplace(mbgl::Milliseconds(delay)); + layer.as()->SymbolLayer::setTextTranslateTransition(options); + } + jni::Object SymbolLayer::getTextTranslateAnchor(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->SymbolLayer::getTextTranslateAnchor()); return jni::Object(*converted); } + jni::Class SymbolLayer::javaClass; jni::jobject* SymbolLayer::createJavaPeer(jni::JNIEnv& env) { @@ -375,18 +533,42 @@ namespace android { METHOD(&SymbolLayer::getTextAllowOverlap, "nativeGetTextAllowOverlap"), METHOD(&SymbolLayer::getTextIgnorePlacement, "nativeGetTextIgnorePlacement"), METHOD(&SymbolLayer::getTextOptional, "nativeGetTextOptional"), + METHOD(&SymbolLayer::getIconOpacityTransition, "nativeGetIconOpacityTransition"), + METHOD(&SymbolLayer::setIconOpacityTransition, "nativeSetIconOpacityTransition"), METHOD(&SymbolLayer::getIconOpacity, "nativeGetIconOpacity"), + METHOD(&SymbolLayer::getIconColorTransition, "nativeGetIconColorTransition"), + METHOD(&SymbolLayer::setIconColorTransition, "nativeSetIconColorTransition"), METHOD(&SymbolLayer::getIconColor, "nativeGetIconColor"), + METHOD(&SymbolLayer::getIconHaloColorTransition, "nativeGetIconHaloColorTransition"), + METHOD(&SymbolLayer::setIconHaloColorTransition, "nativeSetIconHaloColorTransition"), METHOD(&SymbolLayer::getIconHaloColor, "nativeGetIconHaloColor"), + METHOD(&SymbolLayer::getIconHaloWidthTransition, "nativeGetIconHaloWidthTransition"), + METHOD(&SymbolLayer::setIconHaloWidthTransition, "nativeSetIconHaloWidthTransition"), METHOD(&SymbolLayer::getIconHaloWidth, "nativeGetIconHaloWidth"), + METHOD(&SymbolLayer::getIconHaloBlurTransition, "nativeGetIconHaloBlurTransition"), + METHOD(&SymbolLayer::setIconHaloBlurTransition, "nativeSetIconHaloBlurTransition"), METHOD(&SymbolLayer::getIconHaloBlur, "nativeGetIconHaloBlur"), + METHOD(&SymbolLayer::getIconTranslateTransition, "nativeGetIconTranslateTransition"), + METHOD(&SymbolLayer::setIconTranslateTransition, "nativeSetIconTranslateTransition"), METHOD(&SymbolLayer::getIconTranslate, "nativeGetIconTranslate"), METHOD(&SymbolLayer::getIconTranslateAnchor, "nativeGetIconTranslateAnchor"), + METHOD(&SymbolLayer::getTextOpacityTransition, "nativeGetTextOpacityTransition"), + METHOD(&SymbolLayer::setTextOpacityTransition, "nativeSetTextOpacityTransition"), METHOD(&SymbolLayer::getTextOpacity, "nativeGetTextOpacity"), + METHOD(&SymbolLayer::getTextColorTransition, "nativeGetTextColorTransition"), + METHOD(&SymbolLayer::setTextColorTransition, "nativeSetTextColorTransition"), METHOD(&SymbolLayer::getTextColor, "nativeGetTextColor"), + METHOD(&SymbolLayer::getTextHaloColorTransition, "nativeGetTextHaloColorTransition"), + METHOD(&SymbolLayer::setTextHaloColorTransition, "nativeSetTextHaloColorTransition"), METHOD(&SymbolLayer::getTextHaloColor, "nativeGetTextHaloColor"), + METHOD(&SymbolLayer::getTextHaloWidthTransition, "nativeGetTextHaloWidthTransition"), + METHOD(&SymbolLayer::setTextHaloWidthTransition, "nativeSetTextHaloWidthTransition"), METHOD(&SymbolLayer::getTextHaloWidth, "nativeGetTextHaloWidth"), + METHOD(&SymbolLayer::getTextHaloBlurTransition, "nativeGetTextHaloBlurTransition"), + METHOD(&SymbolLayer::setTextHaloBlurTransition, "nativeSetTextHaloBlurTransition"), METHOD(&SymbolLayer::getTextHaloBlur, "nativeGetTextHaloBlur"), + METHOD(&SymbolLayer::getTextTranslateTransition, "nativeGetTextTranslateTransition"), + METHOD(&SymbolLayer::setTextTranslateTransition, "nativeSetTextTranslateTransition"), METHOD(&SymbolLayer::getTextTranslate, "nativeGetTextTranslate"), METHOD(&SymbolLayer::getTextTranslateAnchor, "nativeGetTextTranslateAnchor")); } diff --git a/platform/android/src/style/layers/symbol_layer.hpp b/platform/android/src/style/layers/symbol_layer.hpp index 98ce5572e9..8366051c6e 100644 --- a/platform/android/src/style/layers/symbol_layer.hpp +++ b/platform/android/src/style/layers/symbol_layer.hpp @@ -3,6 +3,7 @@ #pragma once #include "layer.hpp" +#include "../transition_options.hpp" #include #include @@ -26,7 +27,8 @@ public: ~SymbolLayer(); - // Property getters + // Properties + jni::Object getSymbolPlacement(jni::JNIEnv&); jni::Object getSymbolSpacing(jni::JNIEnv&); @@ -96,33 +98,56 @@ public: jni::Object getTextOptional(jni::JNIEnv&); jni::Object getIconOpacity(jni::JNIEnv&); + void setIconOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getIconOpacityTransition(jni::JNIEnv&); jni::Object getIconColor(jni::JNIEnv&); + void setIconColorTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getIconColorTransition(jni::JNIEnv&); jni::Object getIconHaloColor(jni::JNIEnv&); + void setIconHaloColorTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getIconHaloColorTransition(jni::JNIEnv&); jni::Object getIconHaloWidth(jni::JNIEnv&); + void setIconHaloWidthTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getIconHaloWidthTransition(jni::JNIEnv&); jni::Object getIconHaloBlur(jni::JNIEnv&); + void setIconHaloBlurTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getIconHaloBlurTransition(jni::JNIEnv&); jni::Object getIconTranslate(jni::JNIEnv&); + void setIconTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getIconTranslateTransition(jni::JNIEnv&); jni::Object getIconTranslateAnchor(jni::JNIEnv&); jni::Object getTextOpacity(jni::JNIEnv&); + void setTextOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getTextOpacityTransition(jni::JNIEnv&); jni::Object getTextColor(jni::JNIEnv&); + void setTextColorTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getTextColorTransition(jni::JNIEnv&); jni::Object getTextHaloColor(jni::JNIEnv&); + void setTextHaloColorTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getTextHaloColorTransition(jni::JNIEnv&); jni::Object getTextHaloWidth(jni::JNIEnv&); + void setTextHaloWidthTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getTextHaloWidthTransition(jni::JNIEnv&); jni::Object getTextHaloBlur(jni::JNIEnv&); + void setTextHaloBlurTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getTextHaloBlurTransition(jni::JNIEnv&); jni::Object getTextTranslate(jni::JNIEnv&); + void setTextTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay); + jni::Object getTextTranslateTransition(jni::JNIEnv&); jni::Object getTextTranslateAnchor(jni::JNIEnv&); - jni::jobject* createJavaPeer(jni::JNIEnv&); }; // class SymbolLayer diff --git a/platform/android/src/style/transition_options.cpp b/platform/android/src/style/transition_options.cpp new file mode 100644 index 0000000000..c70aa5fe2e --- /dev/null +++ b/platform/android/src/style/transition_options.cpp @@ -0,0 +1,20 @@ +#include "transition_options.hpp" + +namespace mbgl { +namespace android { + +jni::Object TransitionOptions::fromTransitionOptions(jni::JNIEnv& env, jlong duration, jlong delay) { + static auto method = TransitionOptions::javaClass.GetStaticMethod (jlong, jlong)>(env, "fromTransitionOptions"); + return TransitionOptions::javaClass.Call(env, method, duration, delay); +} + +void TransitionOptions::registerNative(jni::JNIEnv& env) { + // Lookup the class + TransitionOptions::javaClass = *jni::Class::Find(env).NewGlobalRef(env).release(); +} + +jni::Class TransitionOptions::javaClass; + + +} // namespace android +} // namespace mbgl \ No newline at end of file diff --git a/platform/android/src/style/transition_options.hpp b/platform/android/src/style/transition_options.hpp new file mode 100644 index 0000000000..3e6b0bc488 --- /dev/null +++ b/platform/android/src/style/transition_options.hpp @@ -0,0 +1,25 @@ +#pragma once + +#include + +#include + +namespace mbgl { +namespace android { + +class TransitionOptions : private mbgl::util::noncopyable { +public: + + static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/TransitionOptions"; }; + + static jni::Object fromTransitionOptions(jni::JNIEnv&, jlong duration, jlong offset); + + static jni::Class javaClass; + + static void registerNative(jni::JNIEnv&); + +}; + + +} // namespace android +} // namespace mbgl \ No newline at end of file -- cgit v1.2.1