android style code

8 files changed, 1387 insertions, 0 deletions

diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/HillshadeLayer.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/HillshadeLayer.java
new file mode 100644
index 0000000000..b2313aa6fe
--- /dev/null
+++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/HillshadeLayer.java
@@ -0,0 +1,337 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+package com.mapbox.mapboxsdk.style.layers;
+
+import android.support.annotation.ColorInt;
+import android.support.annotation.NonNull;
+import android.support.annotation.UiThread;
+
+import static com.mapbox.mapboxsdk.utils.ColorUtils.rgbaToColor;
+
+import com.mapbox.mapboxsdk.style.layers.TransitionOptions;
+
+/**
+ * Client-side hillshading visualization based on DEM data. Currently, the implementation only supports Mapbox Terrain RGB tiles
+ *
+ * @see <a href="https://www.mapbox.com/mapbox-gl-style-spec/#layers-hillshade">The online documentation</a>
+ */
+@UiThread
+public class HillshadeLayer extends Layer {
+
+  /**
+   * Creates a HillshadeLayer.
+   *
+   * @param nativePtr pointer used by core
+   */
+  public HillshadeLayer(long nativePtr) {
+    super(nativePtr);
+  }
+
+  /**
+   * Creates a HillshadeLayer.
+   *
+   * @param layerId  the id of the layer
+   * @param sourceId the id of the source
+   */
+  public HillshadeLayer(String layerId, String sourceId) {
+    initialize(layerId, sourceId);
+  }
+
+  protected native void initialize(String layerId, String sourceId);
+
+  /**
+   * Set the source layer.
+   *
+   * @param sourceLayer the source layer to set
+   */
+  public void setSourceLayer(String sourceLayer) {
+    nativeSetSourceLayer(sourceLayer);
+  }
+
+  /**
+   * Set the source Layer.
+   *
+   * @param sourceLayer the source layer to set
+   * @return This
+   */
+  public HillshadeLayer withSourceLayer(String sourceLayer) {
+    setSourceLayer(sourceLayer);
+    return this;
+  }
+
+  /**
+   * Get the source layer.
+   *
+   * @return sourceLayer the source layer to get
+   */
+  public String getSourceLayer() {
+    return nativeGetSourceLayer();
+  }
+
+  /**
+   * Set a single filter.
+   *
+   * @param filter the filter to set
+   */
+  public void setFilter(Filter.Statement filter) {
+    nativeSetFilter(filter.toArray());
+  }
+
+  /**
+   * Set a single filter.
+   *
+   * @param filter the filter to set
+   * @return This
+   */
+  public HillshadeLayer withFilter(Filter.Statement filter) {
+    setFilter(filter);
+    return this;
+  }
+
+  /**
+   * Set a property or properties.
+   *
+   * @param properties the var-args properties
+   * @return This
+   */
+  public HillshadeLayer withProperties(@NonNull PropertyValue<?>... properties) {
+    setProperties(properties);
+    return this;
+  }
+
+  // Property getters
+
+  /**
+   * Get the HillshadeIlluminationDirection property
+   *
+   * @return property wrapper value around Float
+   */
+  @SuppressWarnings("unchecked")
+  public PropertyValue<Float> getHillshadeIlluminationDirection() {
+    return (PropertyValue<Float>) new PropertyValue("hillshade-illumination-direction", nativeGetHillshadeIlluminationDirection());
+  }
+
+  /**
+   * Get the HillshadeIlluminationDirection property transition options
+   *
+   * @return transition options for Float
+   */
+  public TransitionOptions getHillshadeIlluminationDirectionTransition() {
+    return nativeGetHillshadeIlluminationDirectionTransition();
+  }
+
+  /**
+   * Set the HillshadeIlluminationDirection property transition options
+   *
+   * @param options transition options for Float
+   */
+  public void setHillshadeIlluminationDirectionTransition(TransitionOptions options) {
+    nativeSetHillshadeIlluminationDirectionTransition(options.getDuration(), options.getDelay());
+  }
+
+  /**
+   * Get the HillshadeIlluminationAnchor property
+   *
+   * @return property wrapper value around String
+   */
+  @SuppressWarnings("unchecked")
+  public PropertyValue<String> getHillshadeIlluminationAnchor() {
+    return (PropertyValue<String>) new PropertyValue("hillshade-illumination-anchor", nativeGetHillshadeIlluminationAnchor());
+  }
+
+  /**
+   * Get the HillshadeExaggeration property
+   *
+   * @return property wrapper value around Float
+   */
+  @SuppressWarnings("unchecked")
+  public PropertyValue<Float> getHillshadeExaggeration() {
+    return (PropertyValue<Float>) new PropertyValue("hillshade-exaggeration", nativeGetHillshadeExaggeration());
+  }
+
+  /**
+   * Get the HillshadeExaggeration property transition options
+   *
+   * @return transition options for Float
+   */
+  public TransitionOptions getHillshadeExaggerationTransition() {
+    return nativeGetHillshadeExaggerationTransition();
+  }
+
+  /**
+   * Set the HillshadeExaggeration property transition options
+   *
+   * @param options transition options for Float
+   */
+  public void setHillshadeExaggerationTransition(TransitionOptions options) {
+    nativeSetHillshadeExaggerationTransition(options.getDuration(), options.getDelay());
+  }
+
+  /**
+   * Get the HillshadeShadowColor property
+   *
+   * @return property wrapper value around String
+   */
+  @SuppressWarnings("unchecked")
+  public PropertyValue<String> getHillshadeShadowColor() {
+    return (PropertyValue<String>) new PropertyValue("hillshade-shadow-color", nativeGetHillshadeShadowColor());
+  }
+
+  /**
+   * The shading color of areas that face away from the light source.
+   *
+   * @return int representation of a rgba string color
+   * @throws RuntimeException thrown if property isn't a value
+   */
+  @ColorInt
+  public int getHillshadeShadowColorAsInt() {
+    PropertyValue<String> value = getHillshadeShadowColor();
+    if (value.isValue()) {
+      return rgbaToColor(value.getValue());
+    } else {
+      throw new RuntimeException("hillshade-shadow-color was set as a Function");
+    }
+  }
+
+  /**
+   * Get the HillshadeShadowColor property transition options
+   *
+   * @return transition options for String
+   */
+  public TransitionOptions getHillshadeShadowColorTransition() {
+    return nativeGetHillshadeShadowColorTransition();
+  }
+
+  /**
+   * Set the HillshadeShadowColor property transition options
+   *
+   * @param options transition options for String
+   */
+  public void setHillshadeShadowColorTransition(TransitionOptions options) {
+    nativeSetHillshadeShadowColorTransition(options.getDuration(), options.getDelay());
+  }
+
+  /**
+   * Get the HillshadeHighlightColor property
+   *
+   * @return property wrapper value around String
+   */
+  @SuppressWarnings("unchecked")
+  public PropertyValue<String> getHillshadeHighlightColor() {
+    return (PropertyValue<String>) new PropertyValue("hillshade-highlight-color", nativeGetHillshadeHighlightColor());
+  }
+
+  /**
+   * The shading color of areas that faces towards the light source.
+   *
+   * @return int representation of a rgba string color
+   * @throws RuntimeException thrown if property isn't a value
+   */
+  @ColorInt
+  public int getHillshadeHighlightColorAsInt() {
+    PropertyValue<String> value = getHillshadeHighlightColor();
+    if (value.isValue()) {
+      return rgbaToColor(value.getValue());
+    } else {
+      throw new RuntimeException("hillshade-highlight-color was set as a Function");
+    }
+  }
+
+  /**
+   * Get the HillshadeHighlightColor property transition options
+   *
+   * @return transition options for String
+   */
+  public TransitionOptions getHillshadeHighlightColorTransition() {
+    return nativeGetHillshadeHighlightColorTransition();
+  }
+
+  /**
+   * Set the HillshadeHighlightColor property transition options
+   *
+   * @param options transition options for String
+   */
+  public void setHillshadeHighlightColorTransition(TransitionOptions options) {
+    nativeSetHillshadeHighlightColorTransition(options.getDuration(), options.getDelay());
+  }
+
+  /**
+   * Get the HillshadeAccentColor property
+   *
+   * @return property wrapper value around String
+   */
+  @SuppressWarnings("unchecked")
+  public PropertyValue<String> getHillshadeAccentColor() {
+    return (PropertyValue<String>) new PropertyValue("hillshade-accent-color", nativeGetHillshadeAccentColor());
+  }
+
+  /**
+   * The shading color used to accentuate rugged terrain like sharp cliffs and gorges.
+   *
+   * @return int representation of a rgba string color
+   * @throws RuntimeException thrown if property isn't a value
+   */
+  @ColorInt
+  public int getHillshadeAccentColorAsInt() {
+    PropertyValue<String> value = getHillshadeAccentColor();
+    if (value.isValue()) {
+      return rgbaToColor(value.getValue());
+    } else {
+      throw new RuntimeException("hillshade-accent-color was set as a Function");
+    }
+  }
+
+  /**
+   * Get the HillshadeAccentColor property transition options
+   *
+   * @return transition options for String
+   */
+  public TransitionOptions getHillshadeAccentColorTransition() {
+    return nativeGetHillshadeAccentColorTransition();
+  }
+
+  /**
+   * Set the HillshadeAccentColor property transition options
+   *
+   * @param options transition options for String
+   */
+  public void setHillshadeAccentColorTransition(TransitionOptions options) {
+    nativeSetHillshadeAccentColorTransition(options.getDuration(), options.getDelay());
+  }
+
+  private native Object nativeGetHillshadeIlluminationDirection();
+
+  private native TransitionOptions nativeGetHillshadeIlluminationDirectionTransition();
+
+  private native void nativeSetHillshadeIlluminationDirectionTransition(long duration, long delay);
+
+  private native Object nativeGetHillshadeIlluminationAnchor();
+
+  private native Object nativeGetHillshadeExaggeration();
+
+  private native TransitionOptions nativeGetHillshadeExaggerationTransition();
+
+  private native void nativeSetHillshadeExaggerationTransition(long duration, long delay);
+
+  private native Object nativeGetHillshadeShadowColor();
+
+  private native TransitionOptions nativeGetHillshadeShadowColorTransition();
+
+  private native void nativeSetHillshadeShadowColorTransition(long duration, long delay);
+
+  private native Object nativeGetHillshadeHighlightColor();
+
+  private native TransitionOptions nativeGetHillshadeHighlightColorTransition();
+
+  private native void nativeSetHillshadeHighlightColorTransition(long duration, long delay);
+
+  private native Object nativeGetHillshadeAccentColor();
+
+  private native TransitionOptions nativeGetHillshadeAccentColorTransition();
+
+  private native void nativeSetHillshadeAccentColorTransition(long duration, long delay);
+
+  @Override
+  protected native void finalize() throws Throwable;
+
+}
diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/Property.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/Property.java
index 8d6c7dd055..e52474c35b 100644
--- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/Property.java
+++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/Property.java
@@ -570,6 +570,27 @@ public final class Property {
   @Retention(RetentionPolicy.SOURCE)
   public @interface FILL_EXTRUSION_TRANSLATE_ANCHOR {}
 
+  // HILLSHADE_ILLUMINATION_ANCHOR: Direction of light source when map is rotated.
+
+  /**
+   * The hillshade illumination is relative to the north direction.
+   */
+  public static final String HILLSHADE_ILLUMINATION_ANCHOR_MAP = "map";
+  /**
+   * The hillshade illumination is relative to the top of the viewport.
+   */
+  public static final String HILLSHADE_ILLUMINATION_ANCHOR_VIEWPORT = "viewport";
+
+  /**
+   * Direction of light source when map is rotated.
+   */
+  @StringDef({
+      HILLSHADE_ILLUMINATION_ANCHOR_MAP,
+      HILLSHADE_ILLUMINATION_ANCHOR_VIEWPORT,
+    })
+  @Retention(RetentionPolicy.SOURCE)
+  public @interface HILLSHADE_ILLUMINATION_ANCHOR {}
+
   // ANCHOR: Whether extruded geometries are lit relative to the map or viewport.
 
   /**
diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/PropertyFactory.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/PropertyFactory.java
index 67596fb428..6e644c5591 100644
--- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/PropertyFactory.java
+++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/PropertyFactory.java
@@ -1988,6 +1988,234 @@ public class PropertyFactory {
   }
 
   /**
+   * The direction of the light source used to generate the hillshading with 0 as the top of the viewport if {@link Property.HILLSHADE_ILLUMINATION_ANCHOR} is set to `viewport` and due north if {@link Property.HILLSHADE_ILLUMINATION_ANCHOR} is set to `map`.
+   *
+   * @param value a Float value
+   * @return property wrapper around Float
+   */
+  public static PropertyValue<Float> hillshadeIlluminationDirection(Float value) {
+    return new PaintPropertyValue<>("hillshade-illumination-direction", value);
+  }
+
+  /**
+   * The direction of the light source used to generate the hillshading with 0 as the top of the viewport if {@link Property.HILLSHADE_ILLUMINATION_ANCHOR} is set to `viewport` and due north if {@link Property.HILLSHADE_ILLUMINATION_ANCHOR} is set to `map`.
+   *
+   * @param expression an expression statement
+   * @return property wrapper around an expression statement
+   */
+  public static PropertyValue<Expression> hillshadeIlluminationDirection(Expression expression) {
+    return new PaintPropertyValue<>("hillshade-illumination-direction", expression);
+  }
+
+
+  /**
+   * The direction of the light source used to generate the hillshading with 0 as the top of the viewport if {@link Property.HILLSHADE_ILLUMINATION_ANCHOR} is set to `viewport` and due north if {@link Property.HILLSHADE_ILLUMINATION_ANCHOR} is set to `map`.
+   *
+   * @param <Z> the zoom parameter type
+   * @param function a wrapper {@link CameraFunction} for Float
+   * @return property wrapper around a Float function
+   */
+  @Deprecated
+  public static <Z extends Number> PropertyValue<CameraFunction<Z, Float>> hillshadeIlluminationDirection(CameraFunction<Z, Float> function) {
+    return new PaintPropertyValue<>("hillshade-illumination-direction", function);
+  }
+
+  /**
+   * Direction of light source when map is rotated.
+   *
+   * @param value a String value
+   * @return property wrapper around String
+   */
+  public static PropertyValue<String> hillshadeIlluminationAnchor(@Property.HILLSHADE_ILLUMINATION_ANCHOR String value) {
+    return new PaintPropertyValue<>("hillshade-illumination-anchor", value);
+  }
+
+  /**
+   * Direction of light source when map is rotated.
+   *
+   * @param expression an expression statement
+   * @return property wrapper around an expression statement
+   */
+  public static PropertyValue<Expression> hillshadeIlluminationAnchor(Expression expression) {
+    return new PaintPropertyValue<>("hillshade-illumination-anchor", expression);
+  }
+
+
+  /**
+   * Direction of light source when map is rotated.
+   *
+   * @param <Z> the zoom parameter type
+   * @param function a wrapper {@link CameraFunction} for String
+   * @return property wrapper around a String function
+   */
+  @Deprecated
+  public static <Z extends Number> PropertyValue<CameraFunction<Z, String>> hillshadeIlluminationAnchor(CameraFunction<Z, String> function) {
+    return new PaintPropertyValue<>("hillshade-illumination-anchor", function);
+  }
+
+  /**
+   * Intensity of the hillshade
+   *
+   * @param value a Float value
+   * @return property wrapper around Float
+   */
+  public static PropertyValue<Float> hillshadeExaggeration(Float value) {
+    return new PaintPropertyValue<>("hillshade-exaggeration", value);
+  }
+
+  /**
+   * Intensity of the hillshade
+   *
+   * @param expression an expression statement
+   * @return property wrapper around an expression statement
+   */
+  public static PropertyValue<Expression> hillshadeExaggeration(Expression expression) {
+    return new PaintPropertyValue<>("hillshade-exaggeration", expression);
+  }
+
+
+  /**
+   * Intensity of the hillshade
+   *
+   * @param <Z> the zoom parameter type
+   * @param function a wrapper {@link CameraFunction} for Float
+   * @return property wrapper around a Float function
+   */
+  @Deprecated
+  public static <Z extends Number> PropertyValue<CameraFunction<Z, Float>> hillshadeExaggeration(CameraFunction<Z, Float> function) {
+    return new PaintPropertyValue<>("hillshade-exaggeration", function);
+  }
+
+  /**
+   * The shading color of areas that face away from the light source.
+   *
+   * @param value a int color value
+   * @return property wrapper around String color
+   */
+  public static PropertyValue<String> hillshadeShadowColor(@ColorInt int value) {
+    return new PaintPropertyValue<>("hillshade-shadow-color", colorToRgbaString(value));
+  }
+
+  /**
+   * The shading color of areas that face away from the light source.
+   *
+   * @param value a String value
+   * @return property wrapper around String
+   */
+  public static PropertyValue<String> hillshadeShadowColor(String value) {
+    return new PaintPropertyValue<>("hillshade-shadow-color", value);
+  }
+
+  /**
+   * The shading color of areas that face away from the light source.
+   *
+   * @param expression an expression statement
+   * @return property wrapper around an expression statement
+   */
+  public static PropertyValue<Expression> hillshadeShadowColor(Expression expression) {
+    return new PaintPropertyValue<>("hillshade-shadow-color", expression);
+  }
+
+
+  /**
+   * The shading color of areas that face away from the light source.
+   *
+   * @param <Z> the zoom parameter type
+   * @param function a wrapper {@link CameraFunction} for String
+   * @return property wrapper around a String function
+   */
+  @Deprecated
+  public static <Z extends Number> PropertyValue<CameraFunction<Z, String>> hillshadeShadowColor(CameraFunction<Z, String> function) {
+    return new PaintPropertyValue<>("hillshade-shadow-color", function);
+  }
+
+  /**
+   * The shading color of areas that faces towards the light source.
+   *
+   * @param value a int color value
+   * @return property wrapper around String color
+   */
+  public static PropertyValue<String> hillshadeHighlightColor(@ColorInt int value) {
+    return new PaintPropertyValue<>("hillshade-highlight-color", colorToRgbaString(value));
+  }
+
+  /**
+   * The shading color of areas that faces towards the light source.
+   *
+   * @param value a String value
+   * @return property wrapper around String
+   */
+  public static PropertyValue<String> hillshadeHighlightColor(String value) {
+    return new PaintPropertyValue<>("hillshade-highlight-color", value);
+  }
+
+  /**
+   * The shading color of areas that faces towards the light source.
+   *
+   * @param expression an expression statement
+   * @return property wrapper around an expression statement
+   */
+  public static PropertyValue<Expression> hillshadeHighlightColor(Expression expression) {
+    return new PaintPropertyValue<>("hillshade-highlight-color", expression);
+  }
+
+
+  /**
+   * The shading color of areas that faces towards the light source.
+   *
+   * @param <Z> the zoom parameter type
+   * @param function a wrapper {@link CameraFunction} for String
+   * @return property wrapper around a String function
+   */
+  @Deprecated
+  public static <Z extends Number> PropertyValue<CameraFunction<Z, String>> hillshadeHighlightColor(CameraFunction<Z, String> function) {
+    return new PaintPropertyValue<>("hillshade-highlight-color", function);
+  }
+
+  /**
+   * The shading color used to accentuate rugged terrain like sharp cliffs and gorges.
+   *
+   * @param value a int color value
+   * @return property wrapper around String color
+   */
+  public static PropertyValue<String> hillshadeAccentColor(@ColorInt int value) {
+    return new PaintPropertyValue<>("hillshade-accent-color", colorToRgbaString(value));
+  }
+
+  /**
+   * The shading color used to accentuate rugged terrain like sharp cliffs and gorges.
+   *
+   * @param value a String value
+   * @return property wrapper around String
+   */
+  public static PropertyValue<String> hillshadeAccentColor(String value) {
+    return new PaintPropertyValue<>("hillshade-accent-color", value);
+  }
+
+  /**
+   * The shading color used to accentuate rugged terrain like sharp cliffs and gorges.
+   *
+   * @param expression an expression statement
+   * @return property wrapper around an expression statement
+   */
+  public static PropertyValue<Expression> hillshadeAccentColor(Expression expression) {
+    return new PaintPropertyValue<>("hillshade-accent-color", expression);
+  }
+
+
+  /**
+   * The shading color used to accentuate rugged terrain like sharp cliffs and gorges.
+   *
+   * @param <Z> the zoom parameter type
+   * @param function a wrapper {@link CameraFunction} for String
+   * @return property wrapper around a String function
+   */
+  @Deprecated
+  public static <Z extends Number> PropertyValue<CameraFunction<Z, String>> hillshadeAccentColor(CameraFunction<Z, String> function) {
+    return new PaintPropertyValue<>("hillshade-accent-color", function);
+  }
+
+  /**
    * The color with which the background will be drawn.
    *
    * @param value a int color value
diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/HillshadeLayerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/HillshadeLayerTest.java
new file mode 100644
index 0000000000..54c5992dc2
--- /dev/null
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/HillshadeLayerTest.java
@@ -0,0 +1,544 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+package com.mapbox.mapboxsdk.testapp.style;
+
+import android.graphics.Color;
+import android.support.test.espresso.UiController;
+import android.support.test.runner.AndroidJUnit4;
+
+import timber.log.Timber;
+
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.style.functions.CompositeFunction;
+import com.mapbox.mapboxsdk.style.functions.CameraFunction;
+import com.mapbox.mapboxsdk.style.functions.SourceFunction;
+import com.mapbox.mapboxsdk.style.functions.stops.CategoricalStops;
+import com.mapbox.mapboxsdk.style.functions.stops.ExponentialStops;
+import com.mapbox.mapboxsdk.style.functions.stops.IdentityStops;
+import com.mapbox.mapboxsdk.style.functions.stops.IntervalStops;
+import com.mapbox.mapboxsdk.style.functions.stops.Stop;
+import com.mapbox.mapboxsdk.style.functions.stops.Stops;
+import com.mapbox.mapboxsdk.style.layers.HillshadeLayer;
+import com.mapbox.mapboxsdk.testapp.action.MapboxMapAction;
+import com.mapbox.mapboxsdk.testapp.activity.BaseActivityTest;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static com.mapbox.mapboxsdk.style.functions.Function.*;
+import static com.mapbox.mapboxsdk.style.functions.stops.Stop.stop;
+import static com.mapbox.mapboxsdk.style.functions.stops.Stops.*;
+import static com.mapbox.mapboxsdk.testapp.action.MapboxMapAction.invoke;
+import static org.junit.Assert.*;
+import static com.mapbox.mapboxsdk.style.layers.Property.*;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;
+
+import com.mapbox.mapboxsdk.style.layers.TransitionOptions;
+import com.mapbox.mapboxsdk.testapp.activity.espresso.EspressoTestActivity;
+
+/**
+ * Basic smoke tests for HillshadeLayer
+ */
+@RunWith(AndroidJUnit4.class)
+public class HillshadeLayerTest extends BaseActivityTest {
+
+  private HillshadeLayer layer;
+
+  @Override
+  protected Class getActivityClass() {
+    return EspressoTestActivity.class;
+  }
+
+  private void setupLayer() {
+    Timber.i("Retrieving layer");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+          Timber.i("Adding layer");
+          layer = new HillshadeLayer("my-layer", "composite");
+          layer.setSourceLayer("composite");
+          mapboxMap.addLayer(layer);
+          // Layer reference is now stale, get new reference
+          layer = mapboxMap.getLayerAs("my-layer");
+        }
+      }
+    });
+  }
+
+  @Test
+  public void testSetVisibility() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("Visibility");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Get initial
+        assertEquals(layer.getVisibility().getValue(), VISIBLE);
+
+        // Set
+        layer.setProperties(visibility(NONE));
+        assertEquals(layer.getVisibility().getValue(), NONE);
+      }
+    });
+  }
+
+  @Test
+  public void testSourceLayer() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("SourceLayer");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Get initial
+        assertEquals(layer.getSourceLayer(), "composite");
+
+        // Set
+        final String sourceLayer = "test";
+        layer.setSourceLayer(sourceLayer);
+        assertEquals(layer.getSourceLayer(), sourceLayer);
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeIlluminationDirectionTransition() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-illumination-directionTransitionOptions");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        TransitionOptions options = new TransitionOptions(300, 100);
+        layer.setHillshadeIlluminationDirectionTransition(options);
+        assertEquals(layer.getHillshadeIlluminationDirectionTransition(), options);
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeIlluminationDirectionAsConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-illumination-direction");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        layer.setProperties(hillshadeIlluminationDirection(0.3f));
+        assertEquals((Float) layer.getHillshadeIlluminationDirection().getValue(), (Float) 0.3f);
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeIlluminationDirectionAsCameraFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-illumination-direction");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set
+        layer.setProperties(
+          hillshadeIlluminationDirection(
+            zoom(
+              exponential(
+                stop(2, hillshadeIlluminationDirection(0.3f))
+              ).withBase(0.5f)
+            )
+          )
+        );
+
+        // Verify
+        assertNotNull(layer.getHillshadeIlluminationDirection());
+        assertNotNull(layer.getHillshadeIlluminationDirection().getFunction());
+        assertEquals(CameraFunction.class, layer.getHillshadeIlluminationDirection().getFunction().getClass());
+        assertEquals(ExponentialStops.class, layer.getHillshadeIlluminationDirection().getFunction().getStops().getClass());
+        assertEquals(0.5f, ((ExponentialStops) layer.getHillshadeIlluminationDirection().getFunction().getStops()).getBase(), 0.001);
+        assertEquals(1, ((ExponentialStops) layer.getHillshadeIlluminationDirection().getFunction().getStops()).size());
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeIlluminationAnchorAsConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-illumination-anchor");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        layer.setProperties(hillshadeIlluminationAnchor(HILLSHADE_ILLUMINATION_ANCHOR_MAP));
+        assertEquals((String) layer.getHillshadeIlluminationAnchor().getValue(), (String) HILLSHADE_ILLUMINATION_ANCHOR_MAP);
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeIlluminationAnchorAsCameraFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-illumination-anchor");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set
+        layer.setProperties(
+          hillshadeIlluminationAnchor(
+            zoom(
+              interval(
+                stop(2, hillshadeIlluminationAnchor(HILLSHADE_ILLUMINATION_ANCHOR_MAP))
+              )
+            )
+          )
+        );
+
+        // Verify
+        assertNotNull(layer.getHillshadeIlluminationAnchor());
+        assertNotNull(layer.getHillshadeIlluminationAnchor().getFunction());
+        assertEquals(CameraFunction.class, layer.getHillshadeIlluminationAnchor().getFunction().getClass());
+        assertEquals(IntervalStops.class, layer.getHillshadeIlluminationAnchor().getFunction().getStops().getClass());
+        assertEquals(1, ((IntervalStops) layer.getHillshadeIlluminationAnchor().getFunction().getStops()).size());
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeExaggerationTransition() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-exaggerationTransitionOptions");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        TransitionOptions options = new TransitionOptions(300, 100);
+        layer.setHillshadeExaggerationTransition(options);
+        assertEquals(layer.getHillshadeExaggerationTransition(), options);
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeExaggerationAsConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-exaggeration");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        layer.setProperties(hillshadeExaggeration(0.3f));
+        assertEquals((Float) layer.getHillshadeExaggeration().getValue(), (Float) 0.3f);
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeExaggerationAsCameraFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-exaggeration");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set
+        layer.setProperties(
+          hillshadeExaggeration(
+            zoom(
+              exponential(
+                stop(2, hillshadeExaggeration(0.3f))
+              ).withBase(0.5f)
+            )
+          )
+        );
+
+        // Verify
+        assertNotNull(layer.getHillshadeExaggeration());
+        assertNotNull(layer.getHillshadeExaggeration().getFunction());
+        assertEquals(CameraFunction.class, layer.getHillshadeExaggeration().getFunction().getClass());
+        assertEquals(ExponentialStops.class, layer.getHillshadeExaggeration().getFunction().getStops().getClass());
+        assertEquals(0.5f, ((ExponentialStops) layer.getHillshadeExaggeration().getFunction().getStops()).getBase(), 0.001);
+        assertEquals(1, ((ExponentialStops) layer.getHillshadeExaggeration().getFunction().getStops()).size());
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeShadowColorTransition() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-shadow-colorTransitionOptions");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        TransitionOptions options = new TransitionOptions(300, 100);
+        layer.setHillshadeShadowColorTransition(options);
+        assertEquals(layer.getHillshadeShadowColorTransition(), options);
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeShadowColorAsConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-shadow-color");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        layer.setProperties(hillshadeShadowColor("rgba(0, 0, 0, 1)"));
+        assertEquals((String) layer.getHillshadeShadowColor().getValue(), (String) "rgba(0, 0, 0, 1)");
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeShadowColorAsCameraFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-shadow-color");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set
+        layer.setProperties(
+          hillshadeShadowColor(
+            zoom(
+              exponential(
+                stop(2, hillshadeShadowColor("rgba(0, 0, 0, 1)"))
+              ).withBase(0.5f)
+            )
+          )
+        );
+
+        // Verify
+        assertNotNull(layer.getHillshadeShadowColor());
+        assertNotNull(layer.getHillshadeShadowColor().getFunction());
+        assertEquals(CameraFunction.class, layer.getHillshadeShadowColor().getFunction().getClass());
+        assertEquals(ExponentialStops.class, layer.getHillshadeShadowColor().getFunction().getStops().getClass());
+        assertEquals(0.5f, ((ExponentialStops) layer.getHillshadeShadowColor().getFunction().getStops()).getBase(), 0.001);
+        assertEquals(1, ((ExponentialStops) layer.getHillshadeShadowColor().getFunction().getStops()).size());
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeShadowColorAsIntConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-shadow-color");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        layer.setProperties(hillshadeShadowColor(Color.RED));
+        assertEquals(layer.getHillshadeShadowColorAsInt(), Color.RED);
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeHighlightColorTransition() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-highlight-colorTransitionOptions");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        TransitionOptions options = new TransitionOptions(300, 100);
+        layer.setHillshadeHighlightColorTransition(options);
+        assertEquals(layer.getHillshadeHighlightColorTransition(), options);
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeHighlightColorAsConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-highlight-color");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        layer.setProperties(hillshadeHighlightColor("rgba(0, 0, 0, 1)"));
+        assertEquals((String) layer.getHillshadeHighlightColor().getValue(), (String) "rgba(0, 0, 0, 1)");
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeHighlightColorAsCameraFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-highlight-color");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set
+        layer.setProperties(
+          hillshadeHighlightColor(
+            zoom(
+              exponential(
+                stop(2, hillshadeHighlightColor("rgba(0, 0, 0, 1)"))
+              ).withBase(0.5f)
+            )
+          )
+        );
+
+        // Verify
+        assertNotNull(layer.getHillshadeHighlightColor());
+        assertNotNull(layer.getHillshadeHighlightColor().getFunction());
+        assertEquals(CameraFunction.class, layer.getHillshadeHighlightColor().getFunction().getClass());
+        assertEquals(ExponentialStops.class, layer.getHillshadeHighlightColor().getFunction().getStops().getClass());
+        assertEquals(0.5f, ((ExponentialStops) layer.getHillshadeHighlightColor().getFunction().getStops()).getBase(), 0.001);
+        assertEquals(1, ((ExponentialStops) layer.getHillshadeHighlightColor().getFunction().getStops()).size());
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeHighlightColorAsIntConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-highlight-color");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        layer.setProperties(hillshadeHighlightColor(Color.RED));
+        assertEquals(layer.getHillshadeHighlightColorAsInt(), Color.RED);
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeAccentColorTransition() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-accent-colorTransitionOptions");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        TransitionOptions options = new TransitionOptions(300, 100);
+        layer.setHillshadeAccentColorTransition(options);
+        assertEquals(layer.getHillshadeAccentColorTransition(), options);
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeAccentColorAsConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-accent-color");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        layer.setProperties(hillshadeAccentColor("rgba(0, 0, 0, 1)"));
+        assertEquals((String) layer.getHillshadeAccentColor().getValue(), (String) "rgba(0, 0, 0, 1)");
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeAccentColorAsCameraFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-accent-color");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set
+        layer.setProperties(
+          hillshadeAccentColor(
+            zoom(
+              exponential(
+                stop(2, hillshadeAccentColor("rgba(0, 0, 0, 1)"))
+              ).withBase(0.5f)
+            )
+          )
+        );
+
+        // Verify
+        assertNotNull(layer.getHillshadeAccentColor());
+        assertNotNull(layer.getHillshadeAccentColor().getFunction());
+        assertEquals(CameraFunction.class, layer.getHillshadeAccentColor().getFunction().getClass());
+        assertEquals(ExponentialStops.class, layer.getHillshadeAccentColor().getFunction().getStops().getClass());
+        assertEquals(0.5f, ((ExponentialStops) layer.getHillshadeAccentColor().getFunction().getStops()).getBase(), 0.001);
+        assertEquals(1, ((ExponentialStops) layer.getHillshadeAccentColor().getFunction().getStops()).size());
+      }
+    });
+  }
+
+  @Test
+  public void testHillshadeAccentColorAsIntConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("hillshade-accent-color");
+    invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() {
+      @Override
+      public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) {
+        assertNotNull(layer);
+
+        // Set and Get
+        layer.setProperties(hillshadeAccentColor(Color.RED));
+        assertEquals(layer.getHillshadeAccentColorAsInt(), Color.RED);
+      }
+    });
+  }
+
+}
diff --git a/platform/android/src/style/conversion/types.hpp b/platform/android/src/style/conversion/types.hpp
index 375d1a33aa..8a75b870b3 100644
--- a/platform/android/src/style/conversion/types.hpp
+++ b/platform/android/src/style/conversion/types.hpp
@@ -93,6 +93,13 @@ struct Converter<jni::jobject*, mbgl::style::CirclePitchScaleType> {
 };
 
 template <>
+struct Converter<jni::jobject*, mbgl::style::HillshadeIlluminationAnchorType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::HillshadeIlluminationAnchorType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+template <>
 struct Converter<jni::jobject*, mbgl::style::LightAnchorType> {
     Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::LightAnchorType& value) const {
         return convert<jni::jobject*, std::string>(env, toString(value));
diff --git a/platform/android/src/style/conversion/types_string_values.hpp b/platform/android/src/style/conversion/types_string_values.hpp
index a19ca33a2f..7e4fd4a7f7 100644
--- a/platform/android/src/style/conversion/types_string_values.hpp
+++ b/platform/android/src/style/conversion/types_string_values.hpp
@@ -206,6 +206,20 @@ namespace conversion {
         }
     }
 
+    // hillshade-illumination-anchor
+    inline std::string toString(mbgl::style::HillshadeIlluminationAnchorType value) {
+        switch (value) {
+          case mbgl::style::HillshadeIlluminationAnchorType::Map:
+            return "map";
+            break;
+          case mbgl::style::HillshadeIlluminationAnchorType::Viewport:
+            return "viewport";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
     // anchor
     inline std::string toString(mbgl::style::LightAnchorType value) {
         switch (value) {
diff --git a/platform/android/src/style/layers/hillshade_layer.cpp b/platform/android/src/style/layers/hillshade_layer.cpp
new file mode 100644
index 0000000000..b58bc3b947
--- /dev/null
+++ b/platform/android/src/style/layers/hillshade_layer.cpp
@@ -0,0 +1,178 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include "hillshade_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+#include "../conversion/transition_options.hpp"
+
+namespace mbgl {
+namespace android {
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map) from the JVM side
+     */
+    HillshadeLayer::HillshadeLayer(jni::JNIEnv& env, jni::String layerId, jni::String sourceId)
+        : Layer(env, std::make_unique<mbgl::style::HillshadeLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+    }
+
+    /**
+     * Creates a non-owning peer object (for layers currently attached to the map)
+     */
+    HillshadeLayer::HillshadeLayer(mbgl::Map& map, mbgl::style::HillshadeLayer& coreLayer)
+        : Layer(map, coreLayer) {
+    }
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map)
+     */
+    HillshadeLayer::HillshadeLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::HillshadeLayer> coreLayer)
+        : Layer(map, std::move(coreLayer)) {
+    }
+
+    HillshadeLayer::~HillshadeLayer() = default;
+
+    // Property getters
+
+    jni::Object<jni::ObjectTag> HillshadeLayer::getHillshadeIlluminationDirection(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::getHillshadeIlluminationDirection());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<TransitionOptions> HillshadeLayer::getHillshadeIlluminationDirectionTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::getHillshadeIlluminationDirectionTransition();
+        return *convert<jni::Object<TransitionOptions>>(env, options);
+    }
+
+    void HillshadeLayer::setHillshadeIlluminationDirectionTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::setHillshadeIlluminationDirectionTransition(options);
+    }
+
+    jni::Object<jni::ObjectTag> HillshadeLayer::getHillshadeIlluminationAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::getHillshadeIlluminationAnchor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> HillshadeLayer::getHillshadeExaggeration(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::getHillshadeExaggeration());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<TransitionOptions> HillshadeLayer::getHillshadeExaggerationTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::getHillshadeExaggerationTransition();
+        return *convert<jni::Object<TransitionOptions>>(env, options);
+    }
+
+    void HillshadeLayer::setHillshadeExaggerationTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::setHillshadeExaggerationTransition(options);
+    }
+
+    jni::Object<jni::ObjectTag> HillshadeLayer::getHillshadeShadowColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::getHillshadeShadowColor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<TransitionOptions> HillshadeLayer::getHillshadeShadowColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::getHillshadeShadowColorTransition();
+        return *convert<jni::Object<TransitionOptions>>(env, options);
+    }
+
+    void HillshadeLayer::setHillshadeShadowColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::setHillshadeShadowColorTransition(options);
+    }
+
+    jni::Object<jni::ObjectTag> HillshadeLayer::getHillshadeHighlightColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::getHillshadeHighlightColor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<TransitionOptions> HillshadeLayer::getHillshadeHighlightColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::getHillshadeHighlightColorTransition();
+        return *convert<jni::Object<TransitionOptions>>(env, options);
+    }
+
+    void HillshadeLayer::setHillshadeHighlightColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::setHillshadeHighlightColorTransition(options);
+    }
+
+    jni::Object<jni::ObjectTag> HillshadeLayer::getHillshadeAccentColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::getHillshadeAccentColor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<TransitionOptions> HillshadeLayer::getHillshadeAccentColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::getHillshadeAccentColorTransition();
+        return *convert<jni::Object<TransitionOptions>>(env, options);
+    }
+
+    void HillshadeLayer::setHillshadeAccentColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        layer.as<mbgl::style::HillshadeLayer>()->HillshadeLayer::setHillshadeAccentColorTransition(options);
+    }
+
+
+    jni::Class<HillshadeLayer> HillshadeLayer::javaClass;
+
+    jni::jobject* HillshadeLayer::createJavaPeer(jni::JNIEnv& env) {
+        static auto constructor = HillshadeLayer::javaClass.template GetConstructor<jni::jlong>(env);
+        return HillshadeLayer::javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+    }
+
+    void HillshadeLayer::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        HillshadeLayer::javaClass = *jni::Class<HillshadeLayer>::Find(env).NewGlobalRef(env).release();
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<HillshadeLayer>(
+            env, HillshadeLayer::javaClass, "nativePtr",
+            std::make_unique<HillshadeLayer, JNIEnv&, jni::String, jni::String>,
+            "initialize",
+            "finalize",
+            METHOD(&HillshadeLayer::getHillshadeIlluminationDirectionTransition, "nativeGetHillshadeIlluminationDirectionTransition"),
+            METHOD(&HillshadeLayer::setHillshadeIlluminationDirectionTransition, "nativeSetHillshadeIlluminationDirectionTransition"),
+            METHOD(&HillshadeLayer::getHillshadeIlluminationDirection, "nativeGetHillshadeIlluminationDirection"),
+            METHOD(&HillshadeLayer::getHillshadeIlluminationAnchor, "nativeGetHillshadeIlluminationAnchor"),
+            METHOD(&HillshadeLayer::getHillshadeExaggerationTransition, "nativeGetHillshadeExaggerationTransition"),
+            METHOD(&HillshadeLayer::setHillshadeExaggerationTransition, "nativeSetHillshadeExaggerationTransition"),
+            METHOD(&HillshadeLayer::getHillshadeExaggeration, "nativeGetHillshadeExaggeration"),
+            METHOD(&HillshadeLayer::getHillshadeShadowColorTransition, "nativeGetHillshadeShadowColorTransition"),
+            METHOD(&HillshadeLayer::setHillshadeShadowColorTransition, "nativeSetHillshadeShadowColorTransition"),
+            METHOD(&HillshadeLayer::getHillshadeShadowColor, "nativeGetHillshadeShadowColor"),
+            METHOD(&HillshadeLayer::getHillshadeHighlightColorTransition, "nativeGetHillshadeHighlightColorTransition"),
+            METHOD(&HillshadeLayer::setHillshadeHighlightColorTransition, "nativeSetHillshadeHighlightColorTransition"),
+            METHOD(&HillshadeLayer::getHillshadeHighlightColor, "nativeGetHillshadeHighlightColor"),
+            METHOD(&HillshadeLayer::getHillshadeAccentColorTransition, "nativeGetHillshadeAccentColorTransition"),
+            METHOD(&HillshadeLayer::setHillshadeAccentColorTransition, "nativeSetHillshadeAccentColorTransition"),
+            METHOD(&HillshadeLayer::getHillshadeAccentColor, "nativeGetHillshadeAccentColor"));
+    }
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/layers/hillshade_layer.hpp b/platform/android/src/style/layers/hillshade_layer.hpp
new file mode 100644
index 0000000000..101febb228
--- /dev/null
+++ b/platform/android/src/style/layers/hillshade_layer.hpp
@@ -0,0 +1,58 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include "layer.hpp"
+#include "../transition_options.hpp"
+#include <mbgl/style/layers/hillshade_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class HillshadeLayer : public Layer {
+public:
+
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/HillshadeLayer"; };
+
+    static jni::Class<HillshadeLayer> javaClass;
+
+    static void registerNative(jni::JNIEnv&);
+
+    HillshadeLayer(jni::JNIEnv&, jni::String, jni::String);
+
+    HillshadeLayer(mbgl::Map&, mbgl::style::HillshadeLayer&);
+
+    HillshadeLayer(mbgl::Map&, std::unique_ptr<mbgl::style::HillshadeLayer>);
+
+    ~HillshadeLayer();
+
+    // Properties
+
+    jni::Object<jni::ObjectTag> getHillshadeIlluminationDirection(jni::JNIEnv&);
+    void setHillshadeIlluminationDirectionTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Object<TransitionOptions> getHillshadeIlluminationDirectionTransition(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getHillshadeIlluminationAnchor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getHillshadeExaggeration(jni::JNIEnv&);
+    void setHillshadeExaggerationTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Object<TransitionOptions> getHillshadeExaggerationTransition(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getHillshadeShadowColor(jni::JNIEnv&);
+    void setHillshadeShadowColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Object<TransitionOptions> getHillshadeShadowColorTransition(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getHillshadeHighlightColor(jni::JNIEnv&);
+    void setHillshadeHighlightColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Object<TransitionOptions> getHillshadeHighlightColorTransition(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getHillshadeAccentColor(jni::JNIEnv&);
+    void setHillshadeAccentColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Object<TransitionOptions> getHillshadeAccentColorTransition(jni::JNIEnv&);
+    jni::jobject* createJavaPeer(jni::JNIEnv&);
+
+}; // class HillshadeLayer
+
+} // namespace android
+} // namespace mbgl