[android] #5610 - Runtime style api - part 2

2016-07-26 17:02:52 -04:00
parent ed821c06d9
commit 10b2cc60a7
73 changed files with 6974 additions and 297 deletions
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/BackgroundLayerTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/BackgroundLayerTest.java
@@ -0,0 +1,120 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make style-code-android`.
+package com.mapbox.mapboxsdk.style;
+
+import android.support.test.espresso.Espresso;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+import android.util.Log;
+
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.style.layers.BackgroundLayer;
+import com.mapbox.mapboxsdk.testapp.R;
+import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity;
+import com.mapbox.mapboxsdk.testapp.espresso.BaseTest;
+import com.mapbox.mapboxsdk.testapp.espresso.utils.OnMapReadyIdlingResource;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+import static com.mapbox.mapboxsdk.style.layers.Property.*;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;
+
+/**
+ * Basic smoke tests for BackgroundLayer
+ */
+@RunWith(AndroidJUnit4.class)
+public class BackgroundLayerTest extends BaseTest {
+    private static final String TAG = BackgroundLayerTest.class.getSimpleName();
+
+    @Rule
+    public final ActivityTestRule<RuntimeStyleTestActivity> rule = new ActivityTestRule<>(RuntimeStyleTestActivity.class);
+
+    private BackgroundLayer layer;
+
+    private OnMapReadyIdlingResource idlingResource;
+
+    private MapboxMap mapboxMap;
+
+    @Before
+    public void setup() {
+        idlingResource = new OnMapReadyIdlingResource(rule.getActivity());
+        Espresso.registerIdlingResources(idlingResource);
+    }
+
+    @Test
+    public void testSetVisibility() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        Log.i(TAG, "Retrieving layer");
+        layer = mapboxMap.getLayerAs("background");
+        Log.i(TAG, "visibility");
+        assertNotNull(layer);
+
+        //Get initial
+        assertEquals(layer.getVisibility().getValue(), VISIBLE);
+
+        //Set
+        layer.setProperties(visibility(NONE));
+        assertEquals(layer.getVisibility().getValue(), NONE);
+    }
+
+    @Test
+    public void testBackgroundColor() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        Log.i(TAG, "Retrieving layer");
+        layer = mapboxMap.getLayerAs("background");
+        Log.i(TAG, "background-color");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(backgroundColor("rgba(0, 0, 0, 1)"));
+        assertEquals((String) layer.getBackgroundColor().getValue(), (String) "rgba(0, 0, 0, 1)");
+    }
+
+    @Test
+    public void testBackgroundPattern() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        Log.i(TAG, "Retrieving layer");
+        layer = mapboxMap.getLayerAs("background");
+        Log.i(TAG, "background-pattern");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(backgroundPattern("pedestrian-polygon"));
+        assertEquals((String) layer.getBackgroundPattern().getValue(), (String) "pedestrian-polygon");
+    }
+
+    @Test
+    public void testBackgroundOpacity() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        Log.i(TAG, "Retrieving layer");
+        layer = mapboxMap.getLayerAs("background");
+        Log.i(TAG, "background-opacity");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(backgroundOpacity(0.3f));
+        assertEquals((Float) layer.getBackgroundOpacity().getValue(), (Float) 0.3f);
+    }
+
+
+   @After
+   public void unregisterIntentServiceIdlingResource() {
+       Espresso.unregisterIdlingResources(idlingResource);
+   }
+}
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/CircleLayerTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/CircleLayerTest.java
@@ -0,0 +1,232 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make style-code-android`.
+package com.mapbox.mapboxsdk.style;
+
+import android.support.test.espresso.Espresso;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+import android.util.Log;
+
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.style.layers.CircleLayer;
+import com.mapbox.mapboxsdk.testapp.R;
+import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity;
+import com.mapbox.mapboxsdk.testapp.espresso.BaseTest;
+import com.mapbox.mapboxsdk.testapp.espresso.utils.OnMapReadyIdlingResource;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+import static com.mapbox.mapboxsdk.style.layers.Property.*;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;
+
+/**
+ * Basic smoke tests for CircleLayer
+ */
+@RunWith(AndroidJUnit4.class)
+public class CircleLayerTest extends BaseTest {
+    private static final String TAG = CircleLayerTest.class.getSimpleName();
+
+    @Rule
+    public final ActivityTestRule<RuntimeStyleTestActivity> rule = new ActivityTestRule<>(RuntimeStyleTestActivity.class);
+
+    private CircleLayer layer;
+
+    private OnMapReadyIdlingResource idlingResource;
+
+    private MapboxMap mapboxMap;
+
+    @Before
+    public void setup() {
+        idlingResource = new OnMapReadyIdlingResource(rule.getActivity());
+        Espresso.registerIdlingResources(idlingResource);
+    }
+
+    @Test
+    public void testSetVisibility() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new CircleLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "visibility");
+        assertNotNull(layer);
+
+        //Get initial
+        assertEquals(layer.getVisibility().getValue(), VISIBLE);
+
+        //Set
+        layer.setProperties(visibility(NONE));
+        assertEquals(layer.getVisibility().getValue(), NONE);
+    }
+
+    @Test
+    public void testCircleRadius() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new CircleLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "circle-radius");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(circleRadius(0.3f));
+        assertEquals((Float) layer.getCircleRadius().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testCircleColor() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new CircleLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "circle-color");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(circleColor("rgba(0, 0, 0, 1)"));
+        assertEquals((String) layer.getCircleColor().getValue(), (String) "rgba(0, 0, 0, 1)");
+    }
+
+    @Test
+    public void testCircleBlur() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new CircleLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "circle-blur");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(circleBlur(0.3f));
+        assertEquals((Float) layer.getCircleBlur().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testCircleOpacity() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new CircleLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "circle-opacity");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(circleOpacity(0.3f));
+        assertEquals((Float) layer.getCircleOpacity().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testCircleTranslate() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new CircleLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "circle-translate");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(circleTranslate(new Float[]{0f,0f}));
+        assertEquals((Float[]) layer.getCircleTranslate().getValue(), (Float[]) new Float[]{0f,0f});
+    }
+
+    @Test
+    public void testCircleTranslateAnchor() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new CircleLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "circle-translate-anchor");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(circleTranslateAnchor(CIRCLE_TRANSLATE_ANCHOR_MAP));
+        assertEquals((String) layer.getCircleTranslateAnchor().getValue(), (String) CIRCLE_TRANSLATE_ANCHOR_MAP);
+    }
+
+    @Test
+    public void testCirclePitchScale() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new CircleLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "circle-pitch-scale");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(circlePitchScale(CIRCLE_PITCH_SCALE_MAP));
+        assertEquals((String) layer.getCirclePitchScale().getValue(), (String) CIRCLE_PITCH_SCALE_MAP);
+    }
+
+
+   @After
+   public void unregisterIntentServiceIdlingResource() {
+       Espresso.unregisterIdlingResources(idlingResource);
+   }
+}
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/FillLayerTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/FillLayerTest.java
@@ -0,0 +1,232 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make style-code-android`.
+package com.mapbox.mapboxsdk.style;
+
+import android.support.test.espresso.Espresso;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+import android.util.Log;
+
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.style.layers.FillLayer;
+import com.mapbox.mapboxsdk.testapp.R;
+import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity;
+import com.mapbox.mapboxsdk.testapp.espresso.BaseTest;
+import com.mapbox.mapboxsdk.testapp.espresso.utils.OnMapReadyIdlingResource;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+import static com.mapbox.mapboxsdk.style.layers.Property.*;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;
+
+/**
+ * Basic smoke tests for FillLayer
+ */
+@RunWith(AndroidJUnit4.class)
+public class FillLayerTest extends BaseTest {
+    private static final String TAG = FillLayerTest.class.getSimpleName();
+
+    @Rule
+    public final ActivityTestRule<RuntimeStyleTestActivity> rule = new ActivityTestRule<>(RuntimeStyleTestActivity.class);
+
+    private FillLayer layer;
+
+    private OnMapReadyIdlingResource idlingResource;
+
+    private MapboxMap mapboxMap;
+
+    @Before
+    public void setup() {
+        idlingResource = new OnMapReadyIdlingResource(rule.getActivity());
+        Espresso.registerIdlingResources(idlingResource);
+    }
+
+    @Test
+    public void testSetVisibility() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new FillLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "visibility");
+        assertNotNull(layer);
+
+        //Get initial
+        assertEquals(layer.getVisibility().getValue(), VISIBLE);
+
+        //Set
+        layer.setProperties(visibility(NONE));
+        assertEquals(layer.getVisibility().getValue(), NONE);
+    }
+
+    @Test
+    public void testFillAntialias() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new FillLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "fill-antialias");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(fillAntialias(true));
+        assertEquals((Boolean) layer.getFillAntialias().getValue(), (Boolean) true);
+    }
+
+    @Test
+    public void testFillOpacity() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new FillLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "fill-opacity");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(fillOpacity(0.3f));
+        assertEquals((Float) layer.getFillOpacity().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testFillColor() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new FillLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "fill-color");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(fillColor("rgba(0, 0, 0, 1)"));
+        assertEquals((String) layer.getFillColor().getValue(), (String) "rgba(0, 0, 0, 1)");
+    }
+
+    @Test
+    public void testFillOutlineColor() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new FillLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "fill-outline-color");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(fillOutlineColor("rgba(0, 0, 0, 1)"));
+        assertEquals((String) layer.getFillOutlineColor().getValue(), (String) "rgba(0, 0, 0, 1)");
+    }
+
+    @Test
+    public void testFillTranslate() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new FillLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "fill-translate");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(fillTranslate(new Float[]{0f,0f}));
+        assertEquals((Float[]) layer.getFillTranslate().getValue(), (Float[]) new Float[]{0f,0f});
+    }
+
+    @Test
+    public void testFillTranslateAnchor() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new FillLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "fill-translate-anchor");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(fillTranslateAnchor(FILL_TRANSLATE_ANCHOR_MAP));
+        assertEquals((String) layer.getFillTranslateAnchor().getValue(), (String) FILL_TRANSLATE_ANCHOR_MAP);
+    }
+
+    @Test
+    public void testFillPattern() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new FillLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "fill-pattern");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(fillPattern("pedestrian-polygon"));
+        assertEquals((String) layer.getFillPattern().getValue(), (String) "pedestrian-polygon");
+    }
+
+
+   @After
+   public void unregisterIntentServiceIdlingResource() {
+       Espresso.unregisterIdlingResources(idlingResource);
+   }
+}
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/LineLayerTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/LineLayerTest.java
@@ -0,0 +1,386 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make style-code-android`.
+package com.mapbox.mapboxsdk.style;
+
+import android.support.test.espresso.Espresso;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+import android.util.Log;
+
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.style.layers.LineLayer;
+import com.mapbox.mapboxsdk.testapp.R;
+import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity;
+import com.mapbox.mapboxsdk.testapp.espresso.BaseTest;
+import com.mapbox.mapboxsdk.testapp.espresso.utils.OnMapReadyIdlingResource;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+import static com.mapbox.mapboxsdk.style.layers.Property.*;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;
+
+/**
+ * Basic smoke tests for LineLayer
+ */
+@RunWith(AndroidJUnit4.class)
+public class LineLayerTest extends BaseTest {
+    private static final String TAG = LineLayerTest.class.getSimpleName();
+
+    @Rule
+    public final ActivityTestRule<RuntimeStyleTestActivity> rule = new ActivityTestRule<>(RuntimeStyleTestActivity.class);
+
+    private LineLayer layer;
+
+    private OnMapReadyIdlingResource idlingResource;
+
+    private MapboxMap mapboxMap;
+
+    @Before
+    public void setup() {
+        idlingResource = new OnMapReadyIdlingResource(rule.getActivity());
+        Espresso.registerIdlingResources(idlingResource);
+    }
+
+    @Test
+    public void testSetVisibility() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "visibility");
+        assertNotNull(layer);
+
+        //Get initial
+        assertEquals(layer.getVisibility().getValue(), VISIBLE);
+
+        //Set
+        layer.setProperties(visibility(NONE));
+        assertEquals(layer.getVisibility().getValue(), NONE);
+    }
+
+    @Test
+    public void testLineCap() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-cap");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(lineCap(LINE_CAP_BUTT));
+        assertEquals((String) layer.getLineCap().getValue(), (String) LINE_CAP_BUTT);
+    }
+
+    @Test
+    public void testLineJoin() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-join");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(lineJoin(LINE_JOIN_BEVEL));
+        assertEquals((String) layer.getLineJoin().getValue(), (String) LINE_JOIN_BEVEL);
+    }
+
+    @Test
+    public void testLineMiterLimit() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-miter-limit");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(lineMiterLimit(0.3f));
+        assertEquals((Float) layer.getLineMiterLimit().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testLineRoundLimit() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-round-limit");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(lineRoundLimit(0.3f));
+        assertEquals((Float) layer.getLineRoundLimit().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testLineOpacity() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-opacity");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(lineOpacity(0.3f));
+        assertEquals((Float) layer.getLineOpacity().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testLineColor() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-color");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(lineColor("rgba(0, 0, 0, 1)"));
+        assertEquals((String) layer.getLineColor().getValue(), (String) "rgba(0, 0, 0, 1)");
+    }
+
+    @Test
+    public void testLineTranslate() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-translate");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(lineTranslate(new Float[]{0f,0f}));
+        assertEquals((Float[]) layer.getLineTranslate().getValue(), (Float[]) new Float[]{0f,0f});
+    }
+
+    @Test
+    public void testLineTranslateAnchor() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-translate-anchor");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(lineTranslateAnchor(LINE_TRANSLATE_ANCHOR_MAP));
+        assertEquals((String) layer.getLineTranslateAnchor().getValue(), (String) LINE_TRANSLATE_ANCHOR_MAP);
+    }
+
+    @Test
+    public void testLineWidth() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-width");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(lineWidth(0.3f));
+        assertEquals((Float) layer.getLineWidth().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testLineGapWidth() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-gap-width");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(lineGapWidth(0.3f));
+        assertEquals((Float) layer.getLineGapWidth().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testLineOffset() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-offset");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(lineOffset(0.3f));
+        assertEquals((Float) layer.getLineOffset().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testLineBlur() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-blur");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(lineBlur(0.3f));
+        assertEquals((Float) layer.getLineBlur().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testLineDasharray() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-dasharray");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(lineDasharray(new Float[]{}));
+        assertEquals((Float[]) layer.getLineDasharray().getValue(), (Float[]) new Float[]{});
+    }
+
+    @Test
+    public void testLinePattern() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new LineLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "line-pattern");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(linePattern("pedestrian-polygon"));
+        assertEquals((String) layer.getLinePattern().getValue(), (String) "pedestrian-polygon");
+    }
+
+
+   @After
+   public void unregisterIntentServiceIdlingResource() {
+       Espresso.unregisterIdlingResources(idlingResource);
+   }
+}
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/RasterLayerTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/RasterLayerTest.java
@@ -0,0 +1,232 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make style-code-android`.
+package com.mapbox.mapboxsdk.style;
+
+import android.support.test.espresso.Espresso;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+import android.util.Log;
+
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.style.layers.RasterLayer;
+import com.mapbox.mapboxsdk.testapp.R;
+import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity;
+import com.mapbox.mapboxsdk.testapp.espresso.BaseTest;
+import com.mapbox.mapboxsdk.testapp.espresso.utils.OnMapReadyIdlingResource;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+import static com.mapbox.mapboxsdk.style.layers.Property.*;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;
+
+/**
+ * Basic smoke tests for RasterLayer
+ */
+@RunWith(AndroidJUnit4.class)
+public class RasterLayerTest extends BaseTest {
+    private static final String TAG = RasterLayerTest.class.getSimpleName();
+
+    @Rule
+    public final ActivityTestRule<RuntimeStyleTestActivity> rule = new ActivityTestRule<>(RuntimeStyleTestActivity.class);
+
+    private RasterLayer layer;
+
+    private OnMapReadyIdlingResource idlingResource;
+
+    private MapboxMap mapboxMap;
+
+    @Before
+    public void setup() {
+        idlingResource = new OnMapReadyIdlingResource(rule.getActivity());
+        Espresso.registerIdlingResources(idlingResource);
+    }
+
+    @Test
+    public void testSetVisibility() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new RasterLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "visibility");
+        assertNotNull(layer);
+
+        //Get initial
+        assertEquals(layer.getVisibility().getValue(), VISIBLE);
+
+        //Set
+        layer.setProperties(visibility(NONE));
+        assertEquals(layer.getVisibility().getValue(), NONE);
+    }
+
+    @Test
+    public void testRasterOpacity() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new RasterLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "raster-opacity");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(rasterOpacity(0.3f));
+        assertEquals((Float) layer.getRasterOpacity().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testRasterHueRotate() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new RasterLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "raster-hue-rotate");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(rasterHueRotate(0.3f));
+        assertEquals((Float) layer.getRasterHueRotate().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testRasterBrightnessMin() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new RasterLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "raster-brightness-min");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(rasterBrightnessMin(0.3f));
+        assertEquals((Float) layer.getRasterBrightnessMin().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testRasterBrightnessMax() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new RasterLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "raster-brightness-max");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(rasterBrightnessMax(0.3f));
+        assertEquals((Float) layer.getRasterBrightnessMax().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testRasterSaturation() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new RasterLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "raster-saturation");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(rasterSaturation(0.3f));
+        assertEquals((Float) layer.getRasterSaturation().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testRasterContrast() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new RasterLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "raster-contrast");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(rasterContrast(0.3f));
+        assertEquals((Float) layer.getRasterContrast().getValue(), (Float) 0.3f);
+    }
+
+    @Test
+    public void testRasterFadeDuration() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new RasterLayer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+        Log.i(TAG, "raster-fade-duration");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(rasterFadeDuration(0.3f));
+        assertEquals((Float) layer.getRasterFadeDuration().getValue(), (Float) 0.3f);
+    }
+
+
+   @After
+   public void unregisterIntentServiceIdlingResource() {
+       Espresso.unregisterIdlingResources(idlingResource);
+   }
+}
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/RuntimeStyleBackgroundLayerTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/RuntimeStyleBackgroundLayerTest.java
@@ -0,0 +1,61 @@
+package com.mapbox.mapboxsdk.style;
+
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.ActivityInstrumentationTestCase2;
+import android.util.Log;
+
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
+import com.mapbox.mapboxsdk.style.layers.BackgroundLayer;
+import com.mapbox.mapboxsdk.style.layers.Property;
+import com.mapbox.mapboxsdk.style.layers.PropertyFactory;
+import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * Basic smoke tests for BackgroundLayer
+ */
+@RunWith(AndroidJUnit4.class)
+public class RuntimeStyleBackgroundLayerTest
+        extends ActivityInstrumentationTestCase2<RuntimeStyleTestActivity> {
+    private static final String TAG = RuntimeStyleBackgroundLayerTest.class.getSimpleName();
+
+    public RuntimeStyleBackgroundLayerTest() {
+        super(RuntimeStyleTestActivity.class);
+    }
+
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+        injectInstrumentation(InstrumentationRegistry.getInstrumentation());
+    }
+
+    @Test
+    public void testSetVisibility() {
+        getActivity().mapView.getMapAsync(new OnMapReadyCallback() {
+            @Override
+            public void onMapReady(MapboxMap mapboxMap) {
+                Log.i(TAG, "visibility");
+                BackgroundLayer layer = mapboxMap.getLayerAs("background");
+                assertNotNull(layer);
+
+                //Get initial
+                assertEquals(layer.getVisibility().getValue(), Property.VISIBLE);
+
+                //Set
+                layer.setProperties(PropertyFactory.visibility(Property.NONE));
+                assertEquals(layer.getVisibility().getValue(), Property.NONE);
+            }
+        });
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+    }
+}
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/RuntimeStyleTests.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/RuntimeStyleTests.java
@@ -0,0 +1,91 @@
+package com.mapbox.mapboxsdk.style;
+
+import android.support.test.espresso.Espresso;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.style.layers.FillLayer;
+import com.mapbox.mapboxsdk.style.layers.NoSuchLayerException;
+import com.mapbox.mapboxsdk.style.layers.Property;
+import com.mapbox.mapboxsdk.style.layers.PropertyFactory;
+import com.mapbox.mapboxsdk.style.sources.VectorSource;
+import com.mapbox.mapboxsdk.testapp.R;
+import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity;
+import com.mapbox.mapboxsdk.testapp.espresso.BaseTest;
+import com.mapbox.mapboxsdk.testapp.espresso.utils.OnMapReadyIdlingResource;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Basic smoke tests for Layer and Source
+ */
+@RunWith(AndroidJUnit4.class)
+public class RuntimeStyleTests extends BaseTest {
+
+    @Rule
+    public final ActivityTestRule<RuntimeStyleTestActivity> rule = new ActivityTestRule<>(RuntimeStyleTestActivity.class);
+
+    private OnMapReadyIdlingResource idlingResource;
+
+    @Before
+    public void registerIdlingResource() {
+        idlingResource = new OnMapReadyIdlingResource(rule.getActivity());
+        Espresso.registerIdlingResources(idlingResource);
+    }
+
+    @Test
+    public void testGetAddRemoveLayer() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        MapboxMap mapboxMap = rule.getActivity().getMapboxMap();
+
+        //Get initial
+        assertNotNull(mapboxMap.getLayer("building"));
+
+        //Remove
+        try {
+            mapboxMap.removeLayer("building");
+        } catch (NoSuchLayerException e) {
+            assertFalse(true);
+        }
+        assertNull(mapboxMap.getLayer("building"));
+
+        //Add
+        FillLayer layer = new FillLayer("building", "composite");
+        layer.setSourceLayer("building");
+        mapboxMap.addLayer(layer);
+
+        assertNotNull(mapboxMap.getLayer("building"));
+
+        try {
+            layer.setProperties(PropertyFactory.visibility(Property.VISIBLE));
+            assertTrue("Never reached as the reference is invalid after adding", false);
+        } catch (Exception e) {
+            //Expected, reference is no longer valid
+        }
+    }
+
+    @Test
+    public void testAddRemoveSource() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        MapboxMap mapboxMap = rule.getActivity().getMapboxMap();
+        mapboxMap.addSource(new VectorSource("my-source", "mapbox://mapbox.mapbox-terrain-v2"));
+        mapboxMap.removeSource("my-source");
+    }
+
+    @After
+    public void unregisterIntentServiceIdlingResource() {
+        Espresso.unregisterIdlingResources(idlingResource);
+    }
+}
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/RuntimeStyleTimingTests.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/RuntimeStyleTimingTests.java
@@ -0,0 +1,54 @@
+package com.mapbox.mapboxsdk.style;
+
+import android.support.test.espresso.Espresso;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.style.layers.FillLayer;
+import com.mapbox.mapboxsdk.style.layers.NoSuchLayerException;
+import com.mapbox.mapboxsdk.style.layers.Property;
+import com.mapbox.mapboxsdk.style.layers.PropertyFactory;
+import com.mapbox.mapboxsdk.style.sources.VectorSource;
+import com.mapbox.mapboxsdk.testapp.R;
+import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity;
+import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTimingTestActivity;
+import com.mapbox.mapboxsdk.testapp.espresso.BaseTest;
+import com.mapbox.mapboxsdk.testapp.espresso.utils.OnMapReadyIdlingResource;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+/**
+ * Basic smoke tests for adding Layer and Source as early as possible (in onCreate)
+ */
+@RunWith(AndroidJUnit4.class)
+public class RuntimeStyleTimingTests extends BaseTest {
+
+    @Rule
+    public final ActivityTestRule<RuntimeStyleTimingTestActivity> rule = new ActivityTestRule<>(RuntimeStyleTimingTestActivity.class);
+
+    private OnMapReadyIdlingResource idlingResource;
+
+    @Before
+    public void registerIdlingResource() {
+        idlingResource = new OnMapReadyIdlingResource(rule.getActivity());
+        Espresso.registerIdlingResources(idlingResource);
+    }
+
+    @Test
+    public void testGetAddRemoveLayer() {
+        checkViewIsDisplayed(R.id.mapView);
+        //We're good if it didn't crash
+    }
+
+    @After
+    public void unregisterIntentServiceIdlingResource() {
+        Espresso.unregisterIdlingResources(idlingResource);
+    }
+}
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/SymbolLayerTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/SymbolLayerTest.java
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/layer.junit.ejs
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/style/layer.junit.ejs
@@ -0,0 +1,116 @@
+<%
+  const type = locals.type;
+  const properties = locals.properties;
+-%>
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make style-code-android`.
+package com.mapbox.mapboxsdk.style;
+
+import android.support.test.espresso.Espresso;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+import android.util.Log;
+
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.style.layers.<%- camelize(type) %>Layer;
+import com.mapbox.mapboxsdk.testapp.R;
+import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity;
+import com.mapbox.mapboxsdk.testapp.espresso.BaseTest;
+import com.mapbox.mapboxsdk.testapp.espresso.utils.OnMapReadyIdlingResource;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+import static com.mapbox.mapboxsdk.style.layers.Property.*;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;
+
+/**
+ * Basic smoke tests for <%- camelize(type) %>Layer
+ */
+@RunWith(AndroidJUnit4.class)
+public class <%- camelize(type) %>LayerTest extends BaseTest {
+    private static final String TAG = <%- camelize(type) %>LayerTest.class.getSimpleName();
+
+    @Rule
+    public final ActivityTestRule<RuntimeStyleTestActivity> rule = new ActivityTestRule<>(RuntimeStyleTestActivity.class);
+
+    private <%- camelize(type) %>Layer layer;
+
+    private OnMapReadyIdlingResource idlingResource;
+
+    private MapboxMap mapboxMap;
+
+    @Before
+    public void setup() {
+        idlingResource = new OnMapReadyIdlingResource(rule.getActivity());
+        Espresso.registerIdlingResources(idlingResource);
+    }
+
+    @Test
+    public void testSetVisibility() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+<% if (type === 'background') { -%>
+        Log.i(TAG, "Retrieving layer");
+        layer = mapboxMap.getLayerAs("background");
+<% } else { -%>
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new <%- camelize(type) %>Layer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+<% } -%>
+        Log.i(TAG, "visibility");
+        assertNotNull(layer);
+
+        //Get initial
+        assertEquals(layer.getVisibility().getValue(), VISIBLE);
+
+        //Set
+        layer.setProperties(visibility(NONE));
+        assertEquals(layer.getVisibility().getValue(), NONE);
+    }
+
+<% for (const property of properties) { -%>
+    @Test
+    public void test<%- camelize(property.name) %>() {
+        checkViewIsDisplayed(R.id.mapView);
+
+        mapboxMap = rule.getActivity().getMapboxMap();
+
+<% if (type === 'background') { -%>
+        Log.i(TAG, "Retrieving layer");
+        layer = mapboxMap.getLayerAs("background");
+<% } else { -%>
+        if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
+            Log.i(TAG, "Adding layer");
+            layer = new <%- camelize(type) %>Layer("my-layer", "composite");
+            layer.setSourceLayer("composite");
+            mapboxMap.addLayer(layer);
+            //Layer reference is now stale, get new reference
+            layer = mapboxMap.getLayerAs("my-layer");
+        }
+<% } -%>
+        Log.i(TAG, "<%- property.name %>");
+        assertNotNull(layer);
+
+        //Set and Get
+        layer.setProperties(<%- camelizeWithLeadingLowercase(property.name) %>(<%- defaultValueJava(property) %>));
+        assertEquals((<%- propertyType(property) %>) layer.get<%- camelize(property.name) %>().getValue(), (<%- propertyType(property) %>) <%- defaultValueJava(property) %>);
+    }
+
+<% } -%>
+
+   @After
+   public void unregisterIntentServiceIdlingResource() {
+       Espresso.unregisterIdlingResources(idlingResource);
+   }
+}
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/espresso/utils/OnMapReadyIdlingResource.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/espresso/utils/OnMapReadyIdlingResource.java
@@ -0,0 +1,51 @@
+package com.mapbox.mapboxsdk.testapp.espresso.utils;
+
+import android.app.Activity;
+import android.support.test.espresso.IdlingResource;
+import android.util.Log;
+
+import com.mapbox.mapboxsdk.constants.MapboxConstants;
+
+import java.lang.reflect.Field;
+
+public class OnMapReadyIdlingResource implements IdlingResource {
+
+    private final Activity activity;
+    private IdlingResource.ResourceCallback resourceCallback;
+
+    public OnMapReadyIdlingResource(Activity activity) {
+        this.activity = activity;
+    }
+
+    @Override
+    public String getName() {
+        return getClass().getSimpleName();
+    }
+
+    @Override
+    public boolean isIdleNow() {
+        boolean idle = isMapboxMapReady();
+        if (idle && resourceCallback != null) {
+            resourceCallback.onTransitionToIdle();
+        }
+        return idle;
+    }
+
+    @Override
+    public void registerIdleTransitionCallback(ResourceCallback resourceCallback) {
+        this.resourceCallback = resourceCallback;
+    }
+
+    private boolean isMapboxMapReady() {
+        try {
+            Field field = activity.getClass().getDeclaredField("mapboxMap");
+            field.setAccessible(true);
+            Object value = field.get(activity);
+            Log.e(MapboxConstants.TAG, "isMapboxReady called with value " + (value != null));
+            return value != null;
+        } catch (Exception e) {
+            Log.e(MapboxConstants.TAG, "could not reflect", e);
+            return false;
+        }
+    }
+}
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/main/AndroidManifest.xml
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/AndroidManifest.xml
@@ -317,6 +317,11 @@
                android:value="@string/category_imagegenerator" />
        </activity>

+
+        <!-- For Unit tests -->
+        <activity android:name=".activity.style.RuntimeStyleTestActivity"/>
+        <activity android:name=".activity.style.RuntimeStyleTimingTestActivity"/>
+
        <!-- Configuration Settings -->
        <meta-data
            android:name="com.mapbox.TestEventsServer"
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/FeatureOverviewActivity.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/FeatureOverviewActivity.java
@@ -120,8 +120,8 @@ public class FeatureOverviewActivity extends AppCompatActivity {
    public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) {
        if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            startFeature(features.get(requestCode));
-        }else{
-            Snackbar.make(findViewById(android.R.id.content),"Can't open without the location permission.",Snackbar.LENGTH_SHORT).show();
+        } else {
+            Snackbar.make(findViewById(android.R.id.content), "Can't open without the location permission.", Snackbar.LENGTH_SHORT).show();
        }
    }

@@ -147,7 +147,7 @@ public class FeatureOverviewActivity extends AppCompatActivity {
            String packageName = getApplicationContext().getPackageName();
            String metaDataKey = getString(R.string.category);
            for (ActivityInfo info : app.activities) {
-                if (info.name.startsWith(packageName) && !info.name.equals(FeatureOverviewActivity.class.getName())) {
+                if (info.labelRes != 0 && info.name.startsWith(packageName) && !info.name.equals(FeatureOverviewActivity.class.getName())) {
                    String label = getString(info.labelRes);
                    String description = resolveString(info.descriptionRes);
                    String category = resolveMetaData(info.metaData, metaDataKey);
@@ -176,10 +176,10 @@ public class FeatureOverviewActivity extends AppCompatActivity {
            return category;
        }

-        private String resolveString(@StringRes int stringRes){
-            try{
+        private String resolveString(@StringRes int stringRes) {
+            try {
                return getString(stringRes);
-            }catch (Resources.NotFoundException e){
+            } catch (Resources.NotFoundException e) {
                return "-";
            }
        }
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/customlayer/CustomLayerActivity.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/customlayer/CustomLayerActivity.java
@@ -6,18 +6,21 @@ import android.support.v4.content.ContextCompat;
 import android.support.v7.app.ActionBar;
 import android.support.v7.app.AppCompatActivity;
 import android.support.v7.widget.Toolbar;
+import android.util.Log;
 import android.view.MenuItem;
 import android.view.View;
 import com.mapbox.mapboxsdk.camera.CameraUpdateFactory;
 import com.mapbox.mapboxsdk.geometry.LatLng;
-import com.mapbox.mapboxsdk.layers.CustomLayer;
+import com.mapbox.mapboxsdk.style.layers.CustomLayer;
 import com.mapbox.mapboxsdk.maps.MapView;
 import com.mapbox.mapboxsdk.maps.MapboxMap;
 import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
+import com.mapbox.mapboxsdk.style.layers.NoSuchLayerException;
 import com.mapbox.mapboxsdk.testapp.R;
 import com.mapbox.mapboxsdk.testapp.model.customlayer.ExampleCustomLayer;

 public class CustomLayerActivity extends AppCompatActivity {
+    private static final String TAG = CustomLayerActivity.class.getSimpleName();

    private MapboxMap mapboxMap;
    private MapView mapView;
@@ -66,10 +69,14 @@ public class CustomLayerActivity extends AppCompatActivity {
    private void swapCustomLayer() {

        if (isShowingCustomLayer) {
-            mapboxMap.removeCustomLayer("custom");
+            try {
+                mapboxMap.removeLayer("custom");
+            } catch (NoSuchLayerException e) {
+                Log.e(TAG, "No custom layer to remove");
+            }
            fab.setImageResource(R.drawable.ic_layers_24dp);
        } else {
-            mapboxMap.addCustomLayer(new CustomLayer("custom",
+            mapboxMap.addLayer(new CustomLayer("custom",
                    ExampleCustomLayer.createContext(),
                    ExampleCustomLayer.InitializeFunction,
                    ExampleCustomLayer.RenderFunction,
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/RuntimeStyleActivity.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/RuntimeStyleActivity.java
@@ -6,6 +6,7 @@ import android.support.annotation.RawRes;
 import android.support.v7.app.ActionBar;
 import android.support.v7.app.AppCompatActivity;
 import android.support.v7.widget.Toolbar;
+import android.util.Log;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.widget.Toast;
@@ -16,14 +17,17 @@ import com.mapbox.mapboxsdk.maps.MapView;
 import com.mapbox.mapboxsdk.maps.MapboxMap;
 import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
 import com.mapbox.mapboxsdk.style.layers.FillLayer;
+import com.mapbox.mapboxsdk.style.layers.Function;
 import com.mapbox.mapboxsdk.style.layers.Layer;
 import com.mapbox.mapboxsdk.style.layers.LineLayer;
 import com.mapbox.mapboxsdk.style.layers.NoSuchLayerException;
 import com.mapbox.mapboxsdk.style.layers.Property;
+import com.mapbox.mapboxsdk.style.layers.PropertyValue;
 import com.mapbox.mapboxsdk.style.layers.RasterLayer;
 import com.mapbox.mapboxsdk.style.sources.GeoJsonSource;
 import com.mapbox.mapboxsdk.style.sources.RasterSource;
 import com.mapbox.mapboxsdk.style.sources.Source;
+import com.mapbox.mapboxsdk.style.sources.TileSet;
 import com.mapbox.mapboxsdk.style.sources.VectorSource;
 import com.mapbox.mapboxsdk.testapp.R;

@@ -36,6 +40,7 @@ import java.io.StringWriter;
 import java.io.Writer;

 import static com.mapbox.mapboxsdk.style.layers.Filter.*;
+import static com.mapbox.mapboxsdk.style.layers.Function.*;
 import static com.mapbox.mapboxsdk.style.layers.Property.*;
 import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;

@@ -138,6 +143,12 @@ public class RuntimeStyleActivity extends AppCompatActivity {
            case R.id.action_add_satellite_layer:
                addSatelliteLayer();
                return true;
+            case R.id.action_update_water_color_on_zoom:
+                updateWaterColorOnZoom();
+                return true;
+            case R.id.action_add_custom_tiles:
+                addCustomTileSource();
+                return true;
            default:
                return super.onOptionsItemSelected(item);
        }
@@ -148,7 +159,7 @@ public class RuntimeStyleActivity extends AppCompatActivity {
        for (String roadLayer : roadLayers) {
            Layer layer = mapboxMap.getLayer(roadLayer);
            if (layer != null) {
-                layer.set(visibility(false));
+                layer.setProperties(visibility(VISIBLE));
            }
        }
    }
@@ -162,7 +173,7 @@ public class RuntimeStyleActivity extends AppCompatActivity {
                for (String roadLayer : roadLayers) {
                    Layer layer = mapboxMap.getLayer(roadLayer);
                    if (layer != null) {
-                        layer.set(symbolPlacement(SYMBOL_PLACEMENT_POINT));
+                        layer.setProperties(symbolPlacement(SYMBOL_PLACEMENT_POINT));
                    }
                }
            }
@@ -172,16 +183,16 @@ public class RuntimeStyleActivity extends AppCompatActivity {
    private void setBackgroundOpacity() {
        Layer background = mapboxMap.getLayer("background");
        if (background != null) {
-            background.set(backgroundOpacity(0.2f));
+            background.setProperties(backgroundOpacity(0.2f));
        }
    }

    private void setWaterColor() {
        Layer water = mapboxMap.getLayer("water");
        if (water != null) {
-            water.set(
-                visibility(true),
-                fillColor(Color.RED)
+            water.setProperties(
+                    visibility(VISIBLE),
+                    fillColor(Color.RED)
            );
        } else {
            Toast.makeText(RuntimeStyleActivity.this, "No water layer in this style", Toast.LENGTH_SHORT).show();
@@ -210,7 +221,7 @@ public class RuntimeStyleActivity extends AppCompatActivity {
        mapboxMap.addSource(source);

        FillLayer layer = new FillLayer("parksLayer", "amsterdam-spots");
-        layer.set(
+        layer.setProperties(
                fillColor(Color.RED),
                fillOutlineColor(Color.BLUE),
                fillOpacity(0.3f),
@@ -224,7 +235,18 @@ public class RuntimeStyleActivity extends AppCompatActivity {
        //layer.setPaintProperty(fillColor(Color.RED)); //XXX But not after the object is attached

        //Or get the object later and set it. It's all good.
-        mapboxMap.getLayer("parksLayer").set(fillColor(Color.RED));
+        mapboxMap.getLayer("parksLayer").setProperties(fillColor(Color.RED));
+
+        //You can get a typed layer, if you're sure it's of that type. Use with care
+        layer = mapboxMap.getLayerAs("parksLayer");
+        //And get some properties
+        PropertyValue<Boolean> fillAntialias = layer.getFillAntialias();
+        Log.d(TAG, "Fill anti alias: " + fillAntialias.getValue());
+        layer.setProperties(fillTranslateAnchor(FILL_TRANSLATE_ANCHOR_MAP));
+        PropertyValue<String> fillTranslateAnchor = layer.getFillTranslateAnchor();
+        Log.d(TAG, "Fill translate anchor: " + fillTranslateAnchor.getValue());
+        PropertyValue<String> visibility = layer.getVisibility();
+        Log.d(TAG, "Visibility: " + visibility.getValue());

        //Get a good look at it all
        mapboxMap.animateCamera(CameraUpdateFactory.zoomTo(12));
@@ -237,7 +259,7 @@ public class RuntimeStyleActivity extends AppCompatActivity {

        LineLayer layer = new LineLayer("terrainLayer", "my-terrain-source");
        layer.setSourceLayer("contour");
-        layer.set(
+        layer.setProperties(
                lineJoin(Property.LINE_JOIN_ROUND),
                lineCap(Property.LINE_CAP_ROUND),
                lineColor(Color.RED),
@@ -245,17 +267,50 @@ public class RuntimeStyleActivity extends AppCompatActivity {
        );

        mapboxMap.addLayer(layer);
+
+        //Need to get a fresh handle
+        layer = mapboxMap.getLayerAs("terrainLayer");
+
+        //Make sure it's also applied after the fact
+        layer.setMinZoom(10);
+        layer.setMaxZoom(15);
+
+        layer = (LineLayer) mapboxMap.getLayer("terrainLayer");
+        Toast.makeText(this, String.format("Set min/max zoom to %s - %s", layer.getMinZoom(), layer.getMaxZoom()), Toast.LENGTH_SHORT).show();
    }

    private void addSatelliteLayer() {
        //Add a source
-        Source source = new RasterSource("my-raster-source", "mapbox://mapbox.satellite");
+        Source source = new RasterSource("my-raster-source", "mapbox://mapbox.satellite").withTileSize(512);
        mapboxMap.addSource(source);

        //Add a layer
        mapboxMap.addLayer(new RasterLayer("satellite-layer", "my-raster-source"));
    }

+    private void updateWaterColorOnZoom() {
+        FillLayer layer = mapboxMap.getLayerAs("water");
+        if (layer == null) {
+            return;
+        }
+
+        //Set a zoom function to update the color of the water
+        layer.setProperties(fillColor(zoom(0.8f,
+                stop(1, fillColor(Color.GREEN)),
+                stop(4, fillColor(Color.BLUE)),
+                stop(12, fillColor(Color.RED)),
+                stop(20, fillColor(Color.BLACK))
+        )));
+
+        //do some animations to show it off properly
+        mapboxMap.animateCamera(CameraUpdateFactory.zoomTo(1), 1500);
+
+        PropertyValue<String> fillColor = layer.getFillColor();
+        Function<String> function = fillColor.getFunction();
+        Log.d(TAG, "Fill color base: " + function.getBase());
+        Log.d(TAG, "Fill color #stops: " + function.getStops().length);
+    }
+
    private String readRawResource(@RawRes int rawResource) throws IOException {
        InputStream is = getResources().openRawResource(rawResource);
        Writer writer = new StringWriter();
@@ -284,6 +339,17 @@ public class RuntimeStyleActivity extends AppCompatActivity {
        }
    }

+    private void addCustomTileSource() {
+        //Add a source
+        Source source = new VectorSource("custom-tile-source", new TileSet("2.1.0", "https://vector.mapzen.com/osm/all/{z}/{x}/{y}.mvt?api_key=vector-tiles-LM25tq4"));
+        mapboxMap.addSource(source);
+
+        //Add a layer
+        FillLayer layer = new FillLayer("custom-tile-layers", "custom-tile-source");
+        layer.setSourceLayer("water");
+        mapboxMap.addLayer(layer);
+    }
+
    private static class DefaultCallback implements MapboxMap.CancelableCallback {

        @Override
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/RuntimeStyleTestActivity.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/RuntimeStyleTestActivity.java
@@ -0,0 +1,69 @@
+package com.mapbox.mapboxsdk.testapp.activity.style;
+
+import android.os.Bundle;
+import android.support.v7.app.AppCompatActivity;
+
+import com.mapbox.mapboxsdk.maps.MapView;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
+import com.mapbox.mapboxsdk.testapp.R;
+
+/**
+ * Test activity for unit test execution
+ */
+public class RuntimeStyleTestActivity extends AppCompatActivity {
+    private static final String TAG = RuntimeStyleTestActivity.class.getSimpleName();
+
+    public MapView mapView;
+    private MapboxMap mapboxMap;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_runtime_style);
+
+        //Initialize map as normal
+        mapView = (MapView) findViewById(R.id.mapView);
+        mapView.onCreate(savedInstanceState);
+        mapView.getMapAsync(new OnMapReadyCallback() {
+            @Override
+            public void onMapReady(MapboxMap mapboxMap) {
+                RuntimeStyleTestActivity.this.mapboxMap = mapboxMap;
+            }
+        });
+    }
+
+    public MapboxMap getMapboxMap() {
+        return mapboxMap;
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        mapView.onResume();
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        mapView.onPause();
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        mapView.onSaveInstanceState(outState);
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        mapView.onDestroy();
+    }
+
+    @Override
+    public void onLowMemory() {
+        super.onLowMemory();
+        mapView.onLowMemory();
+    }
+}
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/RuntimeStyleTimingTestActivity.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/RuntimeStyleTimingTestActivity.java
@@ -0,0 +1,87 @@
+package com.mapbox.mapboxsdk.testapp.activity.style;
+
+import android.graphics.Color;
+import android.os.Bundle;
+import android.support.v7.app.AppCompatActivity;
+
+import com.mapbox.mapboxsdk.maps.MapView;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
+import com.mapbox.mapboxsdk.style.layers.CircleLayer;
+import com.mapbox.mapboxsdk.style.sources.VectorSource;
+import com.mapbox.mapboxsdk.testapp.R;
+
+import static com.mapbox.mapboxsdk.style.layers.Property.*;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;
+
+/**
+ * Test activity for unit test execution
+ */
+public class RuntimeStyleTimingTestActivity extends AppCompatActivity {
+    private static final String TAG = RuntimeStyleTimingTestActivity.class.getSimpleName();
+
+    public MapView mapView;
+    private MapboxMap mapboxMap;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_runtime_style);
+
+        //Initialize map as normal
+        mapView = (MapView) findViewById(R.id.mapView);
+        mapView.onCreate(savedInstanceState);
+        mapView.getMapAsync(new OnMapReadyCallback() {
+            @Override
+            public void onMapReady(MapboxMap mapboxMap) {
+                RuntimeStyleTimingTestActivity.this.mapboxMap = mapboxMap;
+                VectorSource museums = new VectorSource("museums_source", "mapbox://mapbox.2opop9hr");
+                mapboxMap.addSource(museums);
+
+                CircleLayer museumsLayer = new CircleLayer("museums", "museums_source");
+                museumsLayer.setSourceLayer("museum-cusco");
+                museumsLayer.setProperties(
+                        visibility(VISIBLE),
+                        circleRadius(8f),
+                        circleColor(Color.argb(1, 55, 148, 179))
+                );
+
+                mapboxMap.addLayer(museumsLayer);
+            }
+        });
+    }
+
+    public MapboxMap getMapboxMap() {
+        return mapboxMap;
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        mapView.onResume();
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        mapView.onPause();
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        mapView.onSaveInstanceState(outState);
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        mapView.onDestroy();
+    }
+
+    @Override
+    public void onLowMemory() {
+        super.onLowMemory();
+        mapView.onLowMemory();
+    }
+}
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/menu/menu_runtime_style.xml
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/res/menu/menu_runtime_style.xml
@@ -34,4 +34,12 @@
        android:id="@+id/action_add_satellite_layer"
        android:title="Add a satellite layer"
        mapbox:showAsAction="never"/>
+    <item
+        android:id="@+id/action_update_water_color_on_zoom"
+        android:title="Change the water color on zoom"
+        mapbox:showAsAction="never"/>
+    <item
+        android:id="@+id/action_add_custom_tiles"
+        android:title="Custom tiles"
+        mapbox:showAsAction="never"/>
 </menu>
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/style/layers/FunctionTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/style/layers/FunctionTest.java
@@ -0,0 +1,29 @@
+package com.mapbox.mapboxsdk.style.layers;
+
+import org.junit.Test;
+
+import static com.mapbox.mapboxsdk.style.layers.Function.*;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;
+
+import static org.junit.Assert.*;
+
+/**
+ * Tests Function
+ */
+public class FunctionTest {
+
+    @Test
+    public void testZoomFunction() {
+        Function zoomF = zoom(
+                stop(1f, lineBlur(1f)),
+                stop(10f, lineBlur(20f))
+        );
+
+        assertNotNull(zoomF.toValueObject());
+        assertArrayEquals(
+                new Object[]{new Object[]{1f, 1f}, new Object[]{10f, 20f}},
+                (Object[]) zoomF.toValueObject().get("stops")
+        );
+    }
+
+}