[core] Render fill-extrusion layers (#8431)

6 files changed, 950 insertions, 16 deletions

diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/BackgroundLayerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/BackgroundLayerTest.java
index 5bab1de904..851660f06e 100644
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/BackgroundLayerTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/BackgroundLayerTest.java
@@ -3,33 +3,42 @@
 package com.mapbox.mapboxsdk.testapp.style;
 
 import android.graphics.Color;
+import android.support.test.espresso.Espresso;
+import android.support.test.rule.ActivityTestRule;
 import android.support.test.runner.AndroidJUnit4;
+import timber.log.Timber;
 
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.style.functions.CompositeFunction;
 import com.mapbox.mapboxsdk.style.functions.CameraFunction;
+import com.mapbox.mapboxsdk.style.functions.SourceFunction;
+import com.mapbox.mapboxsdk.style.functions.stops.CategoricalStops;
 import com.mapbox.mapboxsdk.style.functions.stops.ExponentialStops;
+import com.mapbox.mapboxsdk.style.functions.stops.IdentityStops;
 import com.mapbox.mapboxsdk.style.functions.stops.IntervalStops;
+import com.mapbox.mapboxsdk.style.functions.stops.Stop;
+import com.mapbox.mapboxsdk.style.functions.stops.Stops;
 import com.mapbox.mapboxsdk.style.layers.BackgroundLayer;
-import com.mapbox.mapboxsdk.style.layers.TransitionOptions;
+import com.mapbox.mapboxsdk.testapp.R;
+import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity;
+import com.mapbox.mapboxsdk.testapp.utils.OnMapReadyIdlingResource;
 import com.mapbox.mapboxsdk.testapp.activity.BaseActivityTest;
-import com.mapbox.mapboxsdk.testapp.activity.espresso.EspressoTestActivity;
 
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-import timber.log.Timber;
-
-import static com.mapbox.mapboxsdk.style.functions.Function.zoom;
+import static com.mapbox.mapboxsdk.style.functions.Function.*;
 import static com.mapbox.mapboxsdk.style.functions.stops.Stop.stop;
-import static com.mapbox.mapboxsdk.style.functions.stops.Stops.exponential;
-import static com.mapbox.mapboxsdk.style.functions.stops.Stops.interval;
-import static com.mapbox.mapboxsdk.style.layers.Property.NONE;
-import static com.mapbox.mapboxsdk.style.layers.Property.VISIBLE;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.backgroundColor;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.backgroundOpacity;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.backgroundPattern;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.visibility;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static com.mapbox.mapboxsdk.style.functions.stops.Stops.*;
+import static org.junit.Assert.*;
+import static com.mapbox.mapboxsdk.style.layers.Property.*;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;
+
+import com.mapbox.mapboxsdk.style.layers.TransitionOptions;
+import com.mapbox.mapboxsdk.testapp.activity.espresso.EspressoTestActivity;
 
 /**
  * Basic smoke tests for BackgroundLayer
@@ -44,7 +53,7 @@ public class BackgroundLayerTest extends BaseActivityTest {
     return EspressoTestActivity.class;
   }
 
-  private void setupLayer() {
+  private void setupLayer(){
     Timber.i("Retrieving layer");
     layer = mapboxMap.getLayerAs("background");
   }
diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/FillExtrusionLayerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/FillExtrusionLayerTest.java
new file mode 100644
index 0000000000..fec9a6c119
--- /dev/null
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/FillExtrusionLayerTest.java
@@ -0,0 +1,760 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+package com.mapbox.mapboxsdk.testapp.style;
+
+import android.graphics.Color;
+import android.support.test.espresso.Espresso;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+import timber.log.Timber;
+
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.style.functions.CompositeFunction;
+import com.mapbox.mapboxsdk.style.functions.CameraFunction;
+import com.mapbox.mapboxsdk.style.functions.SourceFunction;
+import com.mapbox.mapboxsdk.style.functions.stops.CategoricalStops;
+import com.mapbox.mapboxsdk.style.functions.stops.ExponentialStops;
+import com.mapbox.mapboxsdk.style.functions.stops.IdentityStops;
+import com.mapbox.mapboxsdk.style.functions.stops.IntervalStops;
+import com.mapbox.mapboxsdk.style.functions.stops.Stop;
+import com.mapbox.mapboxsdk.style.functions.stops.Stops;
+import com.mapbox.mapboxsdk.style.layers.FillExtrusionLayer;
+import com.mapbox.mapboxsdk.testapp.R;
+import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity;
+import com.mapbox.mapboxsdk.testapp.utils.OnMapReadyIdlingResource;
+import com.mapbox.mapboxsdk.testapp.activity.BaseActivityTest;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static com.mapbox.mapboxsdk.style.functions.Function.*;
+import static com.mapbox.mapboxsdk.style.functions.stops.Stop.stop;
+import static com.mapbox.mapboxsdk.style.functions.stops.Stops.*;
+import static org.junit.Assert.*;
+import static com.mapbox.mapboxsdk.style.layers.Property.*;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;
+
+import com.mapbox.mapboxsdk.style.layers.TransitionOptions;
+import com.mapbox.mapboxsdk.testapp.activity.espresso.EspressoTestActivity;
+
+/**
+ * Basic smoke tests for FillExtrusionLayer
+ */
+@RunWith(AndroidJUnit4.class)
+public class FillExtrusionLayerTest extends BaseActivityTest {
+
+  private FillExtrusionLayer layer;
+
+  @Override
+  protected Class getActivityClass() {
+    return EspressoTestActivity.class;
+  }
+
+  private void setupLayer(){
+    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+      Timber.i("Adding layer");
+      layer = new FillExtrusionLayer("my-layer", "composite");
+      layer.setSourceLayer("composite");
+      mapboxMap.addLayer(layer);
+      // Layer reference is now stale, get new reference
+      layer = mapboxMap.getLayerAs("my-layer");
+    }
+  }
+
+  @Test
+  public void testSetVisibility() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("Visibility");
+    assertNotNull(layer);
+
+    // Get initial
+    assertEquals(layer.getVisibility().getValue(), VISIBLE);
+
+    // Set
+    layer.setProperties(visibility(NONE));
+    assertEquals(layer.getVisibility().getValue(), NONE);
+  }
+
+  @Test
+  public void testSourceLayer() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("SourceLayer");
+    assertNotNull(layer);
+
+    // Get initial
+    assertEquals(layer.getSourceLayer(), "composite");
+
+    // Set
+    final String sourceLayer = "test";
+    layer.setSourceLayer(sourceLayer);
+    assertEquals(layer.getSourceLayer(), sourceLayer);
+  }
+
+  @Test
+  public void testFillExtrusionOpacityTransition() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-opacityTransitionOptions");
+    assertNotNull(layer);
+
+    // Set and Get
+    TransitionOptions options = new TransitionOptions(300, 100);
+    layer.setFillExtrusionOpacityTransition(options);
+    assertEquals(layer.getFillExtrusionOpacityTransition(), options);
+  }
+
+  @Test
+  public void testFillExtrusionOpacityAsConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-opacity");
+    assertNotNull(layer);
+
+    // Set and Get
+    layer.setProperties(fillExtrusionOpacity(0.3f));
+    assertEquals((Float) layer.getFillExtrusionOpacity().getValue(), (Float) 0.3f);
+  }
+
+  @Test
+  public void testFillExtrusionOpacityAsCameraFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-opacity");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionOpacity(
+        zoom(
+          exponential(
+            stop(2, fillExtrusionOpacity(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionOpacity());
+    assertNotNull(layer.getFillExtrusionOpacity().getFunction());
+    assertEquals(CameraFunction.class, layer.getFillExtrusionOpacity().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getFillExtrusionOpacity().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getFillExtrusionOpacity().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getFillExtrusionOpacity().getFunction().getStops()).size());
+  }
+
+  @Test
+  public void testFillExtrusionColorTransition() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-colorTransitionOptions");
+    assertNotNull(layer);
+
+    // Set and Get
+    TransitionOptions options = new TransitionOptions(300, 100);
+    layer.setFillExtrusionColorTransition(options);
+    assertEquals(layer.getFillExtrusionColorTransition(), options);
+  }
+
+  @Test
+  public void testFillExtrusionColorAsConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-color");
+    assertNotNull(layer);
+
+    // Set and Get
+    layer.setProperties(fillExtrusionColor("rgba(0, 0, 0, 1)"));
+    assertEquals((String) layer.getFillExtrusionColor().getValue(), (String) "rgba(0, 0, 0, 1)");
+  }
+
+  @Test
+  public void testFillExtrusionColorAsCameraFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-color");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionColor(
+        zoom(
+          exponential(
+            stop(2, fillExtrusionColor("rgba(0, 0, 0, 1)"))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionColor());
+    assertNotNull(layer.getFillExtrusionColor().getFunction());
+    assertEquals(CameraFunction.class, layer.getFillExtrusionColor().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getFillExtrusionColor().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getFillExtrusionColor().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getFillExtrusionColor().getFunction().getStops()).size());
+  }
+
+  @Test
+  public void testFillExtrusionColorAsIdentitySourceFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-color");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionColor(property("FeaturePropertyA", Stops.<String>identity()))
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionColor());
+    assertNotNull(layer.getFillExtrusionColor().getFunction());
+    assertEquals(SourceFunction.class, layer.getFillExtrusionColor().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionColor().getFunction()).getProperty());
+    assertEquals(IdentityStops.class, layer.getFillExtrusionColor().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testFillExtrusionColorAsExponentialSourceFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-color");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionColor(
+        property(
+          "FeaturePropertyA",
+          exponential(
+            stop(Color.RED, fillExtrusionColor(Color.RED))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionColor());
+    assertNotNull(layer.getFillExtrusionColor().getFunction());
+    assertEquals(SourceFunction.class, layer.getFillExtrusionColor().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionColor().getFunction()).getProperty());
+    assertEquals(ExponentialStops.class, layer.getFillExtrusionColor().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testFillExtrusionColorAsCategoricalSourceFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-color");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionColor(
+        property(
+          "FeaturePropertyA",
+          categorical(
+            stop("valueA", fillExtrusionColor(Color.RED))
+          )
+        ).withDefaultValue(fillExtrusionColor(Color.GREEN))
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionColor());
+    assertNotNull(layer.getFillExtrusionColor().getFunction());
+    assertEquals(SourceFunction.class, layer.getFillExtrusionColor().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionColor().getFunction()).getProperty());
+    assertEquals(CategoricalStops.class, layer.getFillExtrusionColor().getFunction().getStops().getClass());
+    assertNotNull(((SourceFunction) layer.getFillExtrusionColor().getFunction()).getDefaultValue());
+    assertNotNull(((SourceFunction) layer.getFillExtrusionColor().getFunction()).getDefaultValue().getValue());
+    assertEquals(Color.GREEN, (int) ((SourceFunction) layer.getFillExtrusionColor().getFunction()).getDefaultValue().getColorInt());
+  }
+
+  @Test
+  public void testFillExtrusionColorAsIntConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-color");
+    assertNotNull(layer);
+
+    // Set and Get
+    layer.setProperties(fillExtrusionColor(Color.RED));
+    assertEquals(layer.getFillExtrusionColorAsInt(), Color.RED);
+  }
+
+  @Test
+  public void testFillExtrusionTranslateTransition() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-translateTransitionOptions");
+    assertNotNull(layer);
+
+    // Set and Get
+    TransitionOptions options = new TransitionOptions(300, 100);
+    layer.setFillExtrusionTranslateTransition(options);
+    assertEquals(layer.getFillExtrusionTranslateTransition(), options);
+  }
+
+  @Test
+  public void testFillExtrusionTranslateAsConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-translate");
+    assertNotNull(layer);
+
+    // Set and Get
+    layer.setProperties(fillExtrusionTranslate(new Float[]{0f,0f}));
+    assertEquals((Float[]) layer.getFillExtrusionTranslate().getValue(), (Float[]) new Float[]{0f,0f});
+  }
+
+  @Test
+  public void testFillExtrusionTranslateAsCameraFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-translate");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionTranslate(
+        zoom(
+          exponential(
+            stop(2, fillExtrusionTranslate(new Float[]{0f,0f}))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionTranslate());
+    assertNotNull(layer.getFillExtrusionTranslate().getFunction());
+    assertEquals(CameraFunction.class, layer.getFillExtrusionTranslate().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getFillExtrusionTranslate().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getFillExtrusionTranslate().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getFillExtrusionTranslate().getFunction().getStops()).size());
+  }
+
+  @Test
+  public void testFillExtrusionTranslateAnchorAsConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-translate-anchor");
+    assertNotNull(layer);
+
+    // Set and Get
+    layer.setProperties(fillExtrusionTranslateAnchor(FILL_EXTRUSION_TRANSLATE_ANCHOR_MAP));
+    assertEquals((String) layer.getFillExtrusionTranslateAnchor().getValue(), (String) FILL_EXTRUSION_TRANSLATE_ANCHOR_MAP);
+  }
+
+  @Test
+  public void testFillExtrusionTranslateAnchorAsCameraFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-translate-anchor");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionTranslateAnchor(
+        zoom(
+          interval(
+            stop(2, fillExtrusionTranslateAnchor(FILL_EXTRUSION_TRANSLATE_ANCHOR_MAP))
+          )
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionTranslateAnchor());
+    assertNotNull(layer.getFillExtrusionTranslateAnchor().getFunction());
+    assertEquals(CameraFunction.class, layer.getFillExtrusionTranslateAnchor().getFunction().getClass());
+    assertEquals(IntervalStops.class, layer.getFillExtrusionTranslateAnchor().getFunction().getStops().getClass());
+    assertEquals(1, ((IntervalStops) layer.getFillExtrusionTranslateAnchor().getFunction().getStops()).size());
+  }
+
+  @Test
+  public void testFillExtrusionPatternTransition() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-patternTransitionOptions");
+    assertNotNull(layer);
+
+    // Set and Get
+    TransitionOptions options = new TransitionOptions(300, 100);
+    layer.setFillExtrusionPatternTransition(options);
+    assertEquals(layer.getFillExtrusionPatternTransition(), options);
+  }
+
+  @Test
+  public void testFillExtrusionPatternAsConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-pattern");
+    assertNotNull(layer);
+
+    // Set and Get
+    layer.setProperties(fillExtrusionPattern("pedestrian-polygon"));
+    assertEquals((String) layer.getFillExtrusionPattern().getValue(), (String) "pedestrian-polygon");
+  }
+
+  @Test
+  public void testFillExtrusionPatternAsCameraFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-pattern");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionPattern(
+        zoom(
+          interval(
+            stop(2, fillExtrusionPattern("pedestrian-polygon"))
+          )
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionPattern());
+    assertNotNull(layer.getFillExtrusionPattern().getFunction());
+    assertEquals(CameraFunction.class, layer.getFillExtrusionPattern().getFunction().getClass());
+    assertEquals(IntervalStops.class, layer.getFillExtrusionPattern().getFunction().getStops().getClass());
+    assertEquals(1, ((IntervalStops) layer.getFillExtrusionPattern().getFunction().getStops()).size());
+  }
+
+  @Test
+  public void testFillExtrusionHeightTransition() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-heightTransitionOptions");
+    assertNotNull(layer);
+
+    // Set and Get
+    TransitionOptions options = new TransitionOptions(300, 100);
+    layer.setFillExtrusionHeightTransition(options);
+    assertEquals(layer.getFillExtrusionHeightTransition(), options);
+  }
+
+  @Test
+  public void testFillExtrusionHeightAsConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-height");
+    assertNotNull(layer);
+
+    // Set and Get
+    layer.setProperties(fillExtrusionHeight(0.3f));
+    assertEquals((Float) layer.getFillExtrusionHeight().getValue(), (Float) 0.3f);
+  }
+
+  @Test
+  public void testFillExtrusionHeightAsCameraFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-height");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionHeight(
+        zoom(
+          exponential(
+            stop(2, fillExtrusionHeight(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionHeight());
+    assertNotNull(layer.getFillExtrusionHeight().getFunction());
+    assertEquals(CameraFunction.class, layer.getFillExtrusionHeight().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getFillExtrusionHeight().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getFillExtrusionHeight().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getFillExtrusionHeight().getFunction().getStops()).size());
+  }
+
+  @Test
+  public void testFillExtrusionHeightAsIdentitySourceFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-height");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionHeight(property("FeaturePropertyA", Stops.<Float>identity()))
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionHeight());
+    assertNotNull(layer.getFillExtrusionHeight().getFunction());
+    assertEquals(SourceFunction.class, layer.getFillExtrusionHeight().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionHeight().getFunction()).getProperty());
+    assertEquals(IdentityStops.class, layer.getFillExtrusionHeight().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testFillExtrusionHeightAsExponentialSourceFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-height");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionHeight(
+        property(
+          "FeaturePropertyA",
+          exponential(
+            stop(0.3f, fillExtrusionHeight(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionHeight());
+    assertNotNull(layer.getFillExtrusionHeight().getFunction());
+    assertEquals(SourceFunction.class, layer.getFillExtrusionHeight().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionHeight().getFunction()).getProperty());
+    assertEquals(ExponentialStops.class, layer.getFillExtrusionHeight().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testFillExtrusionHeightAsCategoricalSourceFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-height");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionHeight(
+        property(
+          "FeaturePropertyA",
+          categorical(
+            stop(1.0f, fillExtrusionHeight(0.3f))
+          )
+        ).withDefaultValue(fillExtrusionHeight(0.3f))
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionHeight());
+    assertNotNull(layer.getFillExtrusionHeight().getFunction());
+    assertEquals(SourceFunction.class, layer.getFillExtrusionHeight().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionHeight().getFunction()).getProperty());
+    assertEquals(CategoricalStops.class, layer.getFillExtrusionHeight().getFunction().getStops().getClass());
+    assertNotNull(((SourceFunction) layer.getFillExtrusionHeight().getFunction()).getDefaultValue());
+    assertNotNull(((SourceFunction) layer.getFillExtrusionHeight().getFunction()).getDefaultValue().getValue());
+    assertEquals(0.3f, ((SourceFunction) layer.getFillExtrusionHeight().getFunction()).getDefaultValue().getValue());
+  }
+
+  @Test
+  public void testFillExtrusionHeightAsCompositeFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-height");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionHeight(
+        composite(
+          "FeaturePropertyA",
+          exponential(
+            stop(0, 0.3f, fillExtrusionHeight(0.9f))
+          ).withBase(0.5f)
+        ).withDefaultValue(fillExtrusionHeight(0.3f))
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionHeight());
+    assertNotNull(layer.getFillExtrusionHeight().getFunction());
+    assertEquals(CompositeFunction.class, layer.getFillExtrusionHeight().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((CompositeFunction) layer.getFillExtrusionHeight().getFunction()).getProperty());
+    assertEquals(ExponentialStops.class, layer.getFillExtrusionHeight().getFunction().getStops().getClass());
+    assertEquals(1, ((ExponentialStops) layer.getFillExtrusionHeight().getFunction().getStops()).size());
+
+    ExponentialStops<Stop.CompositeValue<Float, Float>, Float> stops =
+      (ExponentialStops<Stop.CompositeValue<Float, Float>, Float>) layer.getFillExtrusionHeight().getFunction().getStops();
+    Stop<Stop.CompositeValue<Float, Float>, Float> stop = stops.iterator().next();
+    assertEquals(0f, stop.in.zoom, 0.001);
+    assertEquals(0.3f, stop.in.value, 0.001f);
+    assertEquals(0.9f, stop.out, 0.001f);
+  }
+
+  @Test
+  public void testFillExtrusionBaseTransition() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-baseTransitionOptions");
+    assertNotNull(layer);
+
+    // Set and Get
+    TransitionOptions options = new TransitionOptions(300, 100);
+    layer.setFillExtrusionBaseTransition(options);
+    assertEquals(layer.getFillExtrusionBaseTransition(), options);
+  }
+
+  @Test
+  public void testFillExtrusionBaseAsConstant() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-base");
+    assertNotNull(layer);
+
+    // Set and Get
+    layer.setProperties(fillExtrusionBase(0.3f));
+    assertEquals((Float) layer.getFillExtrusionBase().getValue(), (Float) 0.3f);
+  }
+
+  @Test
+  public void testFillExtrusionBaseAsCameraFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-base");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionBase(
+        zoom(
+          exponential(
+            stop(2, fillExtrusionBase(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionBase());
+    assertNotNull(layer.getFillExtrusionBase().getFunction());
+    assertEquals(CameraFunction.class, layer.getFillExtrusionBase().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getFillExtrusionBase().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getFillExtrusionBase().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getFillExtrusionBase().getFunction().getStops()).size());
+  }
+
+  @Test
+  public void testFillExtrusionBaseAsIdentitySourceFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-base");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionBase(property("FeaturePropertyA", Stops.<Float>identity()))
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionBase());
+    assertNotNull(layer.getFillExtrusionBase().getFunction());
+    assertEquals(SourceFunction.class, layer.getFillExtrusionBase().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionBase().getFunction()).getProperty());
+    assertEquals(IdentityStops.class, layer.getFillExtrusionBase().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testFillExtrusionBaseAsExponentialSourceFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-base");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionBase(
+        property(
+          "FeaturePropertyA",
+          exponential(
+            stop(0.3f, fillExtrusionBase(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionBase());
+    assertNotNull(layer.getFillExtrusionBase().getFunction());
+    assertEquals(SourceFunction.class, layer.getFillExtrusionBase().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionBase().getFunction()).getProperty());
+    assertEquals(ExponentialStops.class, layer.getFillExtrusionBase().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testFillExtrusionBaseAsCategoricalSourceFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-base");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionBase(
+        property(
+          "FeaturePropertyA",
+          categorical(
+            stop(1.0f, fillExtrusionBase(0.3f))
+          )
+        ).withDefaultValue(fillExtrusionBase(0.3f))
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionBase());
+    assertNotNull(layer.getFillExtrusionBase().getFunction());
+    assertEquals(SourceFunction.class, layer.getFillExtrusionBase().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getFillExtrusionBase().getFunction()).getProperty());
+    assertEquals(CategoricalStops.class, layer.getFillExtrusionBase().getFunction().getStops().getClass());
+    assertNotNull(((SourceFunction) layer.getFillExtrusionBase().getFunction()).getDefaultValue());
+    assertNotNull(((SourceFunction) layer.getFillExtrusionBase().getFunction()).getDefaultValue().getValue());
+    assertEquals(0.3f, ((SourceFunction) layer.getFillExtrusionBase().getFunction()).getDefaultValue().getValue());
+  }
+
+  @Test
+  public void testFillExtrusionBaseAsCompositeFunction() {
+    validateTestSetup();
+    setupLayer();
+    Timber.i("fill-extrusion-base");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      fillExtrusionBase(
+        composite(
+          "FeaturePropertyA",
+          exponential(
+            stop(0, 0.3f, fillExtrusionBase(0.9f))
+          ).withBase(0.5f)
+        ).withDefaultValue(fillExtrusionBase(0.3f))
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getFillExtrusionBase());
+    assertNotNull(layer.getFillExtrusionBase().getFunction());
+    assertEquals(CompositeFunction.class, layer.getFillExtrusionBase().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((CompositeFunction) layer.getFillExtrusionBase().getFunction()).getProperty());
+    assertEquals(ExponentialStops.class, layer.getFillExtrusionBase().getFunction().getStops().getClass());
+    assertEquals(1, ((ExponentialStops) layer.getFillExtrusionBase().getFunction().getStops()).size());
+
+    ExponentialStops<Stop.CompositeValue<Float, Float>, Float> stops =
+      (ExponentialStops<Stop.CompositeValue<Float, Float>, Float>) layer.getFillExtrusionBase().getFunction().getStops();
+    Stop<Stop.CompositeValue<Float, Float>, Float> stop = stops.iterator().next();
+    assertEquals(0f, stop.in.zoom, 0.001);
+    assertEquals(0.3f, stop.in.value, 0.001f);
+    assertEquals(0.9f, stop.out, 0.001f);
+  }
+
+}
diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/AndroidManifest.xml b/platform/android/MapboxGLAndroidSDKTestApp/src/main/AndroidManifest.xml
index 2d2a262055..fc10a01356 100644
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/main/AndroidManifest.xml
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/AndroidManifest.xml
@@ -448,6 +448,17 @@
                 android:value=".activity.FeatureOverviewActivity"/>
         </activity>
         <activity
+            android:name=".activity.style.FillExtrusionActivity"
+            android:description="@string/description_fill_extrusion_layer"
+            android:label="@string/activity_fill_extrusion_layer">
+            <meta-data
+                android:name="@string/category"
+                android:value="@string/category_style"/>
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value=".activity.FeatureOverviewActivity"/>
+        </activity>
+        <activity
             android:name=".activity.style.SymbolLayerActivity"
             android:description="@string/description_symbol_layer"
             android:label="@string/activity_symbol_layer">
diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/FillExtrusionActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/FillExtrusionActivity.java
new file mode 100644
index 0000000000..9a7790c6e5
--- /dev/null
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/FillExtrusionActivity.java
@@ -0,0 +1,135 @@
+package com.mapbox.mapboxsdk.testapp.activity.style;
+
+import android.graphics.Color;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.v7.app.AppCompatActivity;
+
+import com.mapbox.mapboxsdk.camera.CameraPosition;
+import com.mapbox.mapboxsdk.camera.CameraUpdateFactory;
+import com.mapbox.mapboxsdk.geometry.LatLng;
+import com.mapbox.mapboxsdk.maps.MapView;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
+import com.mapbox.mapboxsdk.style.layers.FillExtrusionLayer;
+import com.mapbox.mapboxsdk.style.sources.GeoJsonSource;
+import com.mapbox.mapboxsdk.testapp.R;
+import com.mapbox.services.commons.geojson.Polygon;
+
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.fillExtrusionColor;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.fillExtrusionHeight;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.fillExtrusionOpacity;
+
+/**
+ * Test activity showcasing fill extrusions
+ */
+public class FillExtrusionActivity extends AppCompatActivity {
+
+  private MapView mapView;
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.activity_fill_extrusion_layer);
+
+    mapView = (MapView) findViewById(R.id.mapView);
+    mapView.onCreate(savedInstanceState);
+    mapView.getMapAsync(new OnMapReadyCallback() {
+      @Override
+      public void onMapReady(@NonNull
+                             final MapboxMap map) {
+        Polygon domTower = Polygon.fromCoordinates(new double[][][] {
+          new double[][] {
+            new double[] {
+              5.12112557888031,
+              52.09071040847704
+            },
+            new double[] {
+              5.121227502822875,
+              52.09053901776669
+            },
+            new double[] {
+              5.121484994888306,
+              52.090601641371805
+            },
+            new double[] {
+              5.1213884353637695,
+              52.090766439912635
+            },
+            new double[] {
+              5.12112557888031,
+              52.09071040847704
+            }
+          }
+        });
+
+        GeoJsonSource source = new GeoJsonSource("extrusion-source", domTower);
+        map.addSource(source);
+
+        map.addLayer(
+          new FillExtrusionLayer("extrusion-layer", source.getId())
+            .withProperties(
+              fillExtrusionHeight(40f),
+              fillExtrusionOpacity(0.5f),
+              fillExtrusionColor(Color.RED)
+            )
+        );
+
+        map.animateCamera(
+          CameraUpdateFactory.newCameraPosition(
+            new CameraPosition.Builder()
+              .target(new LatLng(52.09071040847704, 5.12112557888031))
+              .tilt(45.0)
+              .zoom(18)
+              .build()
+          ),
+          10000
+        );
+      }
+    });
+  }
+
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+    mapView.onStart();
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    mapView.onResume();
+  }
+
+  @Override
+  protected void onPause() {
+    super.onPause();
+    mapView.onPause();
+  }
+
+  @Override
+  protected void onStop() {
+    super.onStop();
+    mapView.onStop();
+  }
+
+  @Override
+  public void onSaveInstanceState(Bundle outState) {
+    super.onSaveInstanceState(outState);
+    mapView.onSaveInstanceState(outState);
+  }
+
+  @Override
+  public void onLowMemory() {
+    super.onLowMemory();
+    mapView.onLowMemory();
+  }
+
+  @Override
+  public void onDestroy() {
+    super.onDestroy();
+    mapView.onDestroy();
+  }
+
+}
diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/layout/activity_fill_extrusion_layer.xml b/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/layout/activity_fill_extrusion_layer.xml
new file mode 100644
index 0000000000..304841dc69
--- /dev/null
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/layout/activity_fill_extrusion_layer.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+                xmlns:app="http://schemas.android.com/apk/res-auto"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:orientation="vertical">
+
+    <com.mapbox.mapboxsdk.maps.MapView
+        android:id="@id/mapView"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        app:mapbox_cameraTargetLat="52.090710"
+        app:mapbox_cameraTargetLng="5.121125"
+        app:mapbox_cameraZoom="10"
+        app:mapbox_styleUrl="@string/mapbox_style_mapbox_streets"/>
+
+</RelativeLayout>
diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/values/strings.xml b/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/values/strings.xml
index 3df14caf0c..6270eac72d 100644
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/values/strings.xml
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/values/strings.xml
@@ -57,6 +57,7 @@
     <string name="activity_marker_view_rectangle">Marker views in rectangle</string>
     <string name="activity_url_transform">Url transform</string>
     <string name="activity_restricted_bounds">Restrict camera to a bounds</string>
+    <string name="activity_fill_extrusion_layer">Fill extrusions</string>
 
     <!--Description-->
     <string name="description_user_location_tracking">Tracks the location of the user</string>
@@ -113,6 +114,7 @@
     <string name="description_circle_layer">Show bus stops and route in Singapore</string>
     <string name="description_url_transform">Transform urls on the fly</string>
     <string name="description_restricted_bounds">Limit viewport to Iceland</string>
+    <string name="description_fill_extrusion_layer">Shows how to add 3D extruded shapes</string>
 
     <!--Categories-->
     <string name="category">category</string>