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

26 files changed, 1563 insertions, 98 deletions

diff --git a/platform/android/src/style/android_conversion.hpp b/platform/android/src/style/android_conversion.hpp
index 5128cce51f..0ccb704c0a 100644
--- a/platform/android/src/style/android_conversion.hpp
+++ b/platform/android/src/style/android_conversion.hpp
@@ -13,10 +13,6 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-
-//XXX
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-
 inline bool isUndefined(const mbgl::android::Value& value) {
     return value.isNull();
 }
@@ -48,7 +44,7 @@ inline optional<mbgl::android::Value> objectMember(const mbgl::android::Value& v
 }
 
 template <class Fn>
-optional<Error> eachMember(const mbgl::android::Value& value, Fn&& fn) {
+optional<Error> eachMember(const mbgl::android::Value&, Fn&&) {
     //TODO
     mbgl::Log::Warning(mbgl::Event::Android, "eachMember not implemented");
     return {};
@@ -92,4 +88,4 @@ inline optional<Value> toValue(const mbgl::android::Value& value) {
 
 } // namespace conversion
 } // namespace style
-} // namespace mbgl
\ No newline at end of file
+} // namespace mbgl
diff --git a/platform/android/src/style/conversion/function.hpp b/platform/android/src/style/conversion/function.hpp
new file mode 100644
index 0000000000..ad09ce02d2
--- /dev/null
+++ b/platform/android/src/style/conversion/function.hpp
@@ -0,0 +1,52 @@
+#pragma once
+
+#include <mbgl/style/property_value.hpp>
+#include "../../conversion/conversion.hpp"
+#include "../../conversion/constant.hpp"
+#include "types.hpp"
+#include "function.hpp"
+
+#include <jni/jni.hpp>
+
+#include <tuple>
+#include <vector>
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+template <class T>
+inline jni::jobject* toFunctionStopJavaArray(jni::JNIEnv& env, std::vector<std::pair<float, T>> value) {
+    static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/Function$Stop")).release();
+    static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "(Ljava/lang/Object;Ljava/lang/Object;)V");
+
+    jni::jarray<jni::jobject>& jarray = jni::NewObjectArray(env, value.size(), *javaClass);
+
+    for(size_t i = 0; i < value.size(); i = i + 1) {
+        jni::SetObjectArrayElement(env, jarray, i, &jni::NewObject(env, *javaClass, *constructor, value[i].first, *convert<jni::jobject*, T>(env, value[i].second)));
+    }
+
+    return &jarray;
+}
+
+template <class T>
+struct Converter<jni::jobject*, mbgl::style::Function<T>> {
+
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::Function<T>& value) const {
+        static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/Function")).release();
+        static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "([Lcom/mapbox/mapboxsdk/style/layers/Function$Stop;)V");
+        static jni::jmethodID* withBase = &jni::GetMethodID(env, *javaClass, "withBase", "(F)Lcom/mapbox/mapboxsdk/style/layers/Function;");
+
+        //Create object
+        jni::jobject* jfunction = &jni::NewObject(env, *javaClass, *constructor, *toFunctionStopJavaArray(env, value.getStops()));
+
+        //Set base
+        jni::CallMethod<jni::jobject*>(env, jfunction, *withBase, value.getBase());
+
+        return {jfunction};
+    }
+};
+
+} // namespace conversion
+} // namespace android
+} // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/style/conversion/property_value.hpp b/platform/android/src/style/conversion/property_value.hpp
new file mode 100644
index 0000000000..4121192f3f
--- /dev/null
+++ b/platform/android/src/style/conversion/property_value.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <mbgl/style/property_value.hpp>
+#include "../../conversion/conversion.hpp"
+#include "../../conversion/constant.hpp"
+#include "types.hpp"
+#include "function.hpp"
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+template <class T>
+struct Converter<jni::jobject*, mbgl::style::PropertyValue<T>> {
+
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::PropertyValue<T>& value) const {
+
+        if(value.isUndefined()) {
+            //Return a nullptr representing a Java null value
+            return {nullptr};
+        } else if (value.isConstant()) {
+            //Time to convert the constant value
+            Result<jni::jobject*> result = convert<jni::jobject*, T>(env, value.asConstant());
+            return {*result};
+            //return converted;
+        } else if (value.isFunction()) {
+            //Must be a function than
+            return convert<jni::jobject*, mbgl::style::Function<T>>(env, value.asFunction());
+        } else {
+            throw std::runtime_error("Unknown property value type");
+        }
+
+    }
+};
+
+} // namespace conversion
+} // namespace android
+} // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/style/conversion/types.hpp b/platform/android/src/style/conversion/types.hpp
new file mode 100644
index 0000000000..d3c12ff89a
--- /dev/null
+++ b/platform/android/src/style/conversion/types.hpp
@@ -0,0 +1,98 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make style-code-android`.
+#pragma once
+
+#include "types_string_values.hpp"
+#include "../../conversion/conversion.hpp"
+#include "../../conversion/constant.hpp"
+
+#include <mbgl/style/types.hpp>
+#include <mbgl/util/optional.hpp>
+#include <jni/jni.hpp>
+
+#include <string>
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+template <>
+struct Converter<jni::jobject*, mbgl::style::VisibilityType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::VisibilityType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+template <>
+struct Converter<jni::jobject*, mbgl::style::LineCapType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::LineCapType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+template <>
+struct Converter<jni::jobject*, mbgl::style::LineJoinType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::LineJoinType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+template <>
+struct Converter<jni::jobject*, mbgl::style::SymbolPlacementType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::SymbolPlacementType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+template <>
+struct Converter<jni::jobject*, mbgl::style::AlignmentType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::AlignmentType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+template <>
+struct Converter<jni::jobject*, mbgl::style::IconTextFitType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::IconTextFitType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+template <>
+struct Converter<jni::jobject*, mbgl::style::TextJustifyType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::TextJustifyType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+template <>
+struct Converter<jni::jobject*, mbgl::style::TextAnchorType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::TextAnchorType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+template <>
+struct Converter<jni::jobject*, mbgl::style::TextTransformType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::TextTransformType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+template <>
+struct Converter<jni::jobject*, mbgl::style::TranslateAnchorType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::TranslateAnchorType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+template <>
+struct Converter<jni::jobject*, mbgl::style::CirclePitchScaleType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::CirclePitchScaleType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+
+} // namespace conversion
+} // namespace android
+} // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/style/conversion/types.hpp.ejs b/platform/android/src/style/conversion/types.hpp.ejs
new file mode 100644
index 0000000000..de26d061f7
--- /dev/null
+++ b/platform/android/src/style/conversion/types.hpp.ejs
@@ -0,0 +1,40 @@
+<%
+  const properties = locals.properties;
+-%>
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make style-code-android`.
+#pragma once
+
+#include "types_string_values.hpp"
+#include "../../conversion/conversion.hpp"
+#include "../../conversion/constant.hpp"
+
+#include <mbgl/style/types.hpp>
+#include <mbgl/util/optional.hpp>
+#include <jni/jni.hpp>
+
+#include <string>
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+template <>
+struct Converter<jni::jobject*, mbgl::style::VisibilityType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::VisibilityType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+<% for (const property of properties) { -%>
+template <>
+struct Converter<jni::jobject*, mbgl::style::<%- propertyNativeType(property) %>> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::<%- propertyNativeType(property) %>& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
+<% } -%>
+
+} // namespace conversion
+} // namespace android
+} // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/style/conversion/types_string_values.hpp b/platform/android/src/style/conversion/types_string_values.hpp
new file mode 100644
index 0000000000..35cdb1cbc9
--- /dev/null
+++ b/platform/android/src/style/conversion/types_string_values.hpp
@@ -0,0 +1,209 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make style-code-android`.
+#pragma once
+
+#include <mbgl/style/types.hpp>
+
+#include <string>
+#include <stdexcept>
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+    //visibility
+    inline std::string toString(mbgl::style::VisibilityType value) {
+        switch (value) {
+          case mbgl::style::VisibilityType::Visible:
+            return "visible";
+            break;
+          case mbgl::style::VisibilityType::None:
+            return "none";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
+    //line-cap
+    inline std::string toString(mbgl::style::LineCapType value) {
+        switch (value) {
+          case mbgl::style::LineCapType::Butt:
+            return "butt";
+            break;
+          case mbgl::style::LineCapType::Round:
+            return "round";
+            break;
+          case mbgl::style::LineCapType::Square:
+            return "square";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
+    //line-join
+    inline std::string toString(mbgl::style::LineJoinType value) {
+        switch (value) {
+          case mbgl::style::LineJoinType::Bevel:
+            return "bevel";
+            break;
+          case mbgl::style::LineJoinType::Round:
+            return "round";
+            break;
+          case mbgl::style::LineJoinType::Miter:
+            return "miter";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
+    //symbol-placement
+    inline std::string toString(mbgl::style::SymbolPlacementType value) {
+        switch (value) {
+          case mbgl::style::SymbolPlacementType::Point:
+            return "point";
+            break;
+          case mbgl::style::SymbolPlacementType::Line:
+            return "line";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
+    //icon-rotation-alignment
+    inline std::string toString(mbgl::style::AlignmentType value) {
+        switch (value) {
+          case mbgl::style::AlignmentType::Map:
+            return "map";
+            break;
+          case mbgl::style::AlignmentType::Viewport:
+            return "viewport";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
+    //icon-text-fit
+    inline std::string toString(mbgl::style::IconTextFitType value) {
+        switch (value) {
+          case mbgl::style::IconTextFitType::None:
+            return "none";
+            break;
+          case mbgl::style::IconTextFitType::Both:
+            return "both";
+            break;
+          case mbgl::style::IconTextFitType::Width:
+            return "width";
+            break;
+          case mbgl::style::IconTextFitType::Height:
+            return "height";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
+    //text-justify
+    inline std::string toString(mbgl::style::TextJustifyType value) {
+        switch (value) {
+          case mbgl::style::TextJustifyType::Left:
+            return "left";
+            break;
+          case mbgl::style::TextJustifyType::Center:
+            return "center";
+            break;
+          case mbgl::style::TextJustifyType::Right:
+            return "right";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
+    //text-anchor
+    inline std::string toString(mbgl::style::TextAnchorType value) {
+        switch (value) {
+          case mbgl::style::TextAnchorType::Center:
+            return "center";
+            break;
+          case mbgl::style::TextAnchorType::Left:
+            return "left";
+            break;
+          case mbgl::style::TextAnchorType::Right:
+            return "right";
+            break;
+          case mbgl::style::TextAnchorType::Top:
+            return "top";
+            break;
+          case mbgl::style::TextAnchorType::Bottom:
+            return "bottom";
+            break;
+          case mbgl::style::TextAnchorType::TopLeft:
+            return "top-left";
+            break;
+          case mbgl::style::TextAnchorType::TopRight:
+            return "top-right";
+            break;
+          case mbgl::style::TextAnchorType::BottomLeft:
+            return "bottom-left";
+            break;
+          case mbgl::style::TextAnchorType::BottomRight:
+            return "bottom-right";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
+    //text-transform
+    inline std::string toString(mbgl::style::TextTransformType value) {
+        switch (value) {
+          case mbgl::style::TextTransformType::None:
+            return "none";
+            break;
+          case mbgl::style::TextTransformType::Uppercase:
+            return "uppercase";
+            break;
+          case mbgl::style::TextTransformType::Lowercase:
+            return "lowercase";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
+    //fill-translate-anchor
+    inline std::string toString(mbgl::style::TranslateAnchorType value) {
+        switch (value) {
+          case mbgl::style::TranslateAnchorType::Map:
+            return "map";
+            break;
+          case mbgl::style::TranslateAnchorType::Viewport:
+            return "viewport";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
+    //circle-pitch-scale
+    inline std::string toString(mbgl::style::CirclePitchScaleType value) {
+        switch (value) {
+          case mbgl::style::CirclePitchScaleType::Map:
+            return "map";
+            break;
+          case mbgl::style::CirclePitchScaleType::Viewport:
+            return "viewport";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
+
+} // namespace conversion
+} // namespace android
+} // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/style/conversion/types_string_values.hpp.ejs b/platform/android/src/style/conversion/types_string_values.hpp.ejs
new file mode 100644
index 0000000000..db90a614f5
--- /dev/null
+++ b/platform/android/src/style/conversion/types_string_values.hpp.ejs
@@ -0,0 +1,48 @@
+<%
+  const properties = locals.properties;
+-%>
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make style-code-android`.
+#pragma once
+
+#include <mbgl/style/types.hpp>
+
+#include <string>
+#include <stdexcept>
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+    //visibility
+    inline std::string toString(mbgl::style::VisibilityType value) {
+        switch (value) {
+          case mbgl::style::VisibilityType::Visible:
+            return "visible";
+            break;
+          case mbgl::style::VisibilityType::None:
+            return "none";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
+<% for (const property of properties) { -%>
+    //<%- property.name %>
+    inline std::string toString(mbgl::style::<%- propertyNativeType(property) %> value) {
+        switch (value) {
+<% for (const value of property.values) { -%>
+          case mbgl::style::<%- propertyNativeType(property) %>::<%- camelize(value) %>:
+            return "<%- value %>";
+            break;
+<% } -%>
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
+<% } -%>
+
+} // namespace conversion
+} // namespace android
+} // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/style/layers/background_layer.cpp b/platform/android/src/style/layers/background_layer.cpp
index 4847d59420..25526a07fa 100644
--- a/platform/android/src/style/layers/background_layer.cpp
+++ b/platform/android/src/style/layers/background_layer.cpp
@@ -4,25 +4,41 @@
 
 #include <string>
 
-//XXX
-#include <mbgl/platform/log.hpp>
+#include "../conversion/property_value.hpp"
 
 namespace mbgl {
 namespace android {
 
     BackgroundLayer::BackgroundLayer(jni::JNIEnv& env, jni::String layerId)
         : Layer(env, std::make_unique<mbgl::style::BackgroundLayer>(jni::Make<std::string>(env, layerId))) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "BackgroundLayer constructed, owning reference");
     }
 
     BackgroundLayer::BackgroundLayer(mbgl::Map& map, mbgl::style::BackgroundLayer& coreLayer)
         : Layer(map, coreLayer) {
-
-        mbgl::Log::Debug(mbgl::Event::JNI, "BackgroundLayer Non-owning reference constructor");
     }
 
     BackgroundLayer::~BackgroundLayer() = default;
 
+    // Property getters
+
+    jni::Object<jni::ObjectTag> BackgroundLayer::getBackgroundColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundColor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> BackgroundLayer::getBackgroundPattern(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundPattern());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> BackgroundLayer::getBackgroundOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundOpacity());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
     jni::Class<BackgroundLayer> BackgroundLayer::javaClass;
 
     jni::jobject* BackgroundLayer::createJavaPeer(jni::JNIEnv& env) {
@@ -31,8 +47,6 @@ namespace android {
     }
 
     void BackgroundLayer::registerNative(jni::JNIEnv& env) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "Registering native background layer");
-
         //Lookup the class
         BackgroundLayer::javaClass = *jni::Class<BackgroundLayer>::Find(env).NewGlobalRef(env).release();
 
@@ -43,9 +57,10 @@ namespace android {
             env, BackgroundLayer::javaClass, "nativePtr",
             std::make_unique<BackgroundLayer, JNIEnv&, jni::String>,
             "initialize",
-            "finalize"
-        );
-
+            "finalize",
+            METHOD(&BackgroundLayer::getBackgroundColor, "nativeGetBackgroundColor"),
+            METHOD(&BackgroundLayer::getBackgroundPattern, "nativeGetBackgroundPattern"),
+            METHOD(&BackgroundLayer::getBackgroundOpacity, "nativeGetBackgroundOpacity"));
     }
 
 } // namespace android
diff --git a/platform/android/src/style/layers/background_layer.hpp b/platform/android/src/style/layers/background_layer.hpp
index b253b4861c..f201213e46 100644
--- a/platform/android/src/style/layers/background_layer.hpp
+++ b/platform/android/src/style/layers/background_layer.hpp
@@ -24,8 +24,16 @@ public:
 
     ~BackgroundLayer();
 
+    // Property getters
+    jni::Object<jni::ObjectTag> getBackgroundColor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getBackgroundPattern(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getBackgroundOpacity(jni::JNIEnv&);
+
     jni::jobject* createJavaPeer(jni::JNIEnv&);
-};
+
+}; // class BackgroundLayer
 
 } // namespace android
 } // namespace mbgl
diff --git a/platform/android/src/style/layers/circle_layer.cpp b/platform/android/src/style/layers/circle_layer.cpp
index ad0d0b34ce..c2d6ff06d1 100644
--- a/platform/android/src/style/layers/circle_layer.cpp
+++ b/platform/android/src/style/layers/circle_layer.cpp
@@ -4,25 +4,65 @@
 
 #include <string>
 
-//XXX
-#include <mbgl/platform/log.hpp>
+#include "../conversion/property_value.hpp"
 
 namespace mbgl {
 namespace android {
 
     CircleLayer::CircleLayer(jni::JNIEnv& env, jni::String layerId, jni::String sourceId)
         : Layer(env, std::make_unique<mbgl::style::CircleLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "CircleLayer constructed, owning reference");
     }
 
     CircleLayer::CircleLayer(mbgl::Map& map, mbgl::style::CircleLayer& coreLayer)
         : Layer(map, coreLayer) {
-
-        mbgl::Log::Debug(mbgl::Event::JNI, "CircleLayer Non-owning reference constructor");
     }
 
     CircleLayer::~CircleLayer() = default;
 
+    // Property getters
+
+    jni::Object<jni::ObjectTag> CircleLayer::getCircleRadius(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCircleRadius());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> CircleLayer::getCircleColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCircleColor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> CircleLayer::getCircleBlur(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCircleBlur());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> CircleLayer::getCircleOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCircleOpacity());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> CircleLayer::getCircleTranslate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCircleTranslate());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> CircleLayer::getCircleTranslateAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCircleTranslateAnchor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> CircleLayer::getCirclePitchScale(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCirclePitchScale());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
     jni::Class<CircleLayer> CircleLayer::javaClass;
 
     jni::jobject* CircleLayer::createJavaPeer(jni::JNIEnv& env) {
@@ -31,8 +71,6 @@ namespace android {
     }
 
     void CircleLayer::registerNative(jni::JNIEnv& env) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "Registering native background layer");
-
         //Lookup the class
         CircleLayer::javaClass = *jni::Class<CircleLayer>::Find(env).NewGlobalRef(env).release();
 
@@ -43,9 +81,14 @@ namespace android {
             env, CircleLayer::javaClass, "nativePtr",
             std::make_unique<CircleLayer, JNIEnv&, jni::String, jni::String>,
             "initialize",
-            "finalize"
-        );
-
+            "finalize",
+            METHOD(&CircleLayer::getCircleRadius, "nativeGetCircleRadius"),
+            METHOD(&CircleLayer::getCircleColor, "nativeGetCircleColor"),
+            METHOD(&CircleLayer::getCircleBlur, "nativeGetCircleBlur"),
+            METHOD(&CircleLayer::getCircleOpacity, "nativeGetCircleOpacity"),
+            METHOD(&CircleLayer::getCircleTranslate, "nativeGetCircleTranslate"),
+            METHOD(&CircleLayer::getCircleTranslateAnchor, "nativeGetCircleTranslateAnchor"),
+            METHOD(&CircleLayer::getCirclePitchScale, "nativeGetCirclePitchScale"));
     }
 
 } // namespace android
diff --git a/platform/android/src/style/layers/circle_layer.hpp b/platform/android/src/style/layers/circle_layer.hpp
index e0dc94eb00..91c99c686e 100644
--- a/platform/android/src/style/layers/circle_layer.hpp
+++ b/platform/android/src/style/layers/circle_layer.hpp
@@ -24,8 +24,24 @@ public:
 
     ~CircleLayer();
 
+    // Property getters
+    jni::Object<jni::ObjectTag> getCircleRadius(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getCircleColor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getCircleBlur(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getCircleOpacity(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getCircleTranslate(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getCircleTranslateAnchor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getCirclePitchScale(jni::JNIEnv&);
+
     jni::jobject* createJavaPeer(jni::JNIEnv&);
-};
+
+}; // class CircleLayer
 
 } // namespace android
 } // namespace mbgl
diff --git a/platform/android/src/style/layers/custom_layer.cpp b/platform/android/src/style/layers/custom_layer.cpp
new file mode 100644
index 0000000000..4be6f3800d
--- /dev/null
+++ b/platform/android/src/style/layers/custom_layer.cpp
@@ -0,0 +1,57 @@
+#include "custom_layer.hpp"
+
+#include <string>
+
+#include <mbgl/platform/log.hpp>
+
+namespace mbgl {
+namespace android {
+
+    CustomLayer::CustomLayer(jni::JNIEnv& env, jni::String layerId, jni::jlong initializeFunction, jni::jlong renderFunction, jni::jlong deinitializeFunction, jni::jlong context)
+        : Layer(env, std::make_unique<mbgl::style::CustomLayer>(
+                jni::Make<std::string>(env, layerId),
+                reinterpret_cast<mbgl::style::CustomLayerInitializeFunction>(initializeFunction),
+                reinterpret_cast<mbgl::style::CustomLayerRenderFunction>(renderFunction),
+                reinterpret_cast<mbgl::style::CustomLayerDeinitializeFunction>(deinitializeFunction),
+                reinterpret_cast<void*>(context))
+                ) {
+    }
+
+    CustomLayer::CustomLayer(mbgl::Map& map, mbgl::style::CustomLayer& coreLayer)
+        : Layer(map, coreLayer) {
+    }
+
+    CustomLayer::~CustomLayer() = default;
+
+    void CustomLayer::update(jni::JNIEnv&) {
+        if (map) {
+            map->update(mbgl::Update::Repaint);
+        } else {
+            Log::Error(mbgl::Event::JNI, "No map reference, cannot update");
+        }
+    }
+
+    jni::Class<CustomLayer> CustomLayer::javaClass;
+
+    jni::jobject* CustomLayer::createJavaPeer(jni::JNIEnv& env) {
+        static auto constructor = CustomLayer::javaClass.template GetConstructor<jni::jlong>(env);
+        return CustomLayer::javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+    }
+
+    void CustomLayer::registerNative(jni::JNIEnv& env) {
+        //Lookup the class
+        CustomLayer::javaClass = *jni::Class<CustomLayer>::Find(env).NewGlobalRef(env).release();
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        //Register the peer
+        jni::RegisterNativePeer<CustomLayer>(
+            env, CustomLayer::javaClass, "nativePtr",
+            std::make_unique<CustomLayer, JNIEnv&, jni::String, jni::jlong, jni::jlong, jni::jlong, jni::jlong>,
+            "initialize",
+            "finalize",
+            METHOD(&CustomLayer::update, "nativeUpdate"));
+    }
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/layers/custom_layer.hpp b/platform/android/src/style/layers/custom_layer.hpp
new file mode 100644
index 0000000000..1173d21bfd
--- /dev/null
+++ b/platform/android/src/style/layers/custom_layer.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "layer.hpp"
+#include <mbgl/style/layers/custom_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class CustomLayer : public Layer {
+public:
+
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/CustomLayer"; };
+
+    static jni::Class<CustomLayer> javaClass;
+
+    static void registerNative(jni::JNIEnv&);
+
+    CustomLayer(jni::JNIEnv&, jni::String, jni::jlong, jni::jlong, jni::jlong, jni::jlong);
+
+    CustomLayer(mbgl::Map&, mbgl::style::CustomLayer&);
+
+    ~CustomLayer();
+
+    void update(jni::JNIEnv&);
+
+    jni::jobject* createJavaPeer(jni::JNIEnv&);
+
+}; // class CustomLayer
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/layers/fill_layer.cpp b/platform/android/src/style/layers/fill_layer.cpp
index 1056c8353b..8cb96c9cd3 100644
--- a/platform/android/src/style/layers/fill_layer.cpp
+++ b/platform/android/src/style/layers/fill_layer.cpp
@@ -4,25 +4,65 @@
 
 #include <string>
 
-//XXX
-#include <mbgl/platform/log.hpp>
+#include "../conversion/property_value.hpp"
 
 namespace mbgl {
 namespace android {
 
     FillLayer::FillLayer(jni::JNIEnv& env, jni::String layerId, jni::String sourceId)
         : Layer(env, std::make_unique<mbgl::style::FillLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "FillLayer constructed, owning reference");
     }
 
     FillLayer::FillLayer(mbgl::Map& map, mbgl::style::FillLayer& coreLayer)
         : Layer(map, coreLayer) {
-
-        mbgl::Log::Debug(mbgl::Event::JNI, "FillLayer Non-owning reference constructor");
     }
 
     FillLayer::~FillLayer() = default;
 
+    // Property getters
+
+    jni::Object<jni::ObjectTag> FillLayer::getFillAntialias(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillAntialias());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> FillLayer::getFillOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillOpacity());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> FillLayer::getFillColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillColor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> FillLayer::getFillOutlineColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillOutlineColor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> FillLayer::getFillTranslate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillTranslate());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> FillLayer::getFillTranslateAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillTranslateAnchor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> FillLayer::getFillPattern(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillPattern());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
     jni::Class<FillLayer> FillLayer::javaClass;
 
     jni::jobject* FillLayer::createJavaPeer(jni::JNIEnv& env) {
@@ -31,8 +71,6 @@ namespace android {
     }
 
     void FillLayer::registerNative(jni::JNIEnv& env) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "Registering native background layer");
-
         //Lookup the class
         FillLayer::javaClass = *jni::Class<FillLayer>::Find(env).NewGlobalRef(env).release();
 
@@ -43,9 +81,14 @@ namespace android {
             env, FillLayer::javaClass, "nativePtr",
             std::make_unique<FillLayer, JNIEnv&, jni::String, jni::String>,
             "initialize",
-            "finalize"
-        );
-
+            "finalize",
+            METHOD(&FillLayer::getFillAntialias, "nativeGetFillAntialias"),
+            METHOD(&FillLayer::getFillOpacity, "nativeGetFillOpacity"),
+            METHOD(&FillLayer::getFillColor, "nativeGetFillColor"),
+            METHOD(&FillLayer::getFillOutlineColor, "nativeGetFillOutlineColor"),
+            METHOD(&FillLayer::getFillTranslate, "nativeGetFillTranslate"),
+            METHOD(&FillLayer::getFillTranslateAnchor, "nativeGetFillTranslateAnchor"),
+            METHOD(&FillLayer::getFillPattern, "nativeGetFillPattern"));
     }
 
 } // namespace android
diff --git a/platform/android/src/style/layers/fill_layer.hpp b/platform/android/src/style/layers/fill_layer.hpp
index 5ed80d401f..5dbd7a3412 100644
--- a/platform/android/src/style/layers/fill_layer.hpp
+++ b/platform/android/src/style/layers/fill_layer.hpp
@@ -24,8 +24,24 @@ public:
 
     ~FillLayer();
 
+    // Property getters
+    jni::Object<jni::ObjectTag> getFillAntialias(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getFillOpacity(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getFillColor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getFillOutlineColor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getFillTranslate(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getFillTranslateAnchor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getFillPattern(jni::JNIEnv&);
+
     jni::jobject* createJavaPeer(jni::JNIEnv&);
-};
+
+}; // class FillLayer
 
 } // namespace android
 } // namespace mbgl
diff --git a/platform/android/src/style/layers/layer.cpp b/platform/android/src/style/layers/layer.cpp
index aec7079698..4d5f90f67e 100644
--- a/platform/android/src/style/layers/layer.cpp
+++ b/platform/android/src/style/layers/layer.cpp
@@ -4,10 +4,15 @@
 #include <jni/jni.hpp>
 
 #include <mbgl/platform/log.hpp>
+
+//Java -> C++ conversion
 #include <mbgl/style/conversion.hpp>
 #include <mbgl/style/conversion/layer.hpp>
 #include <mbgl/style/conversion/source.hpp>
 
+//C++ -> Java conversion
+#include "../conversion/property_value.hpp"
+
 #include <string>
 
 namespace mbgl {
@@ -16,19 +21,15 @@ namespace android {
     /**
      * Invoked when the construction is initiated from the jvm through a subclass
      */
-    Layer::Layer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> coreLayer)
+    Layer::Layer(jni::JNIEnv&, std::unique_ptr<mbgl::style::Layer> coreLayer)
         : ownedLayer(std::move(coreLayer))
         , layer(*ownedLayer) {
-
-        mbgl::Log::Debug(mbgl::Event::JNI, "Layer constructed, owning reference");
     }
 
     Layer::Layer(mbgl::Map& coreMap, mbgl::style::Layer& coreLayer) : layer(coreLayer) , map(&coreMap) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "Non-owning reference constructor");
     }
 
     Layer::~Layer() {
-        mbgl::Log::Debug(mbgl::Event::JNI, "Layer destroyed");
     }
 
     jni::String Layer::getId(jni::JNIEnv& env) {
@@ -41,8 +42,6 @@ namespace android {
     }
 
     void Layer::setLayoutProperty(jni::JNIEnv& env, jni::String jname, jni::Object<> jvalue) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "Set layout property");
-
         Value value(env, jvalue);
 
         //Convert and set property
@@ -51,16 +50,9 @@ namespace android {
             mbgl::Log::Error(mbgl::Event::JNI, "Error setting property: " + jni::Make<std::string>(env, jname) + " " + error->message);
             return;
         }
-
-        //Update the style if attached
-        if (ownedLayer == nullptr) {
-            map->update(mbgl::Update::RecalculateStyle);
-        }
     }
 
     void Layer::setPaintProperty(jni::JNIEnv& env, jni::String jname, jni::Object<> jvalue) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "Set paint property");
-
         Value value(env, jvalue);
 
         //Convert and set property
@@ -72,8 +64,6 @@ namespace android {
     }
 
     void Layer::updateStyle(jni::JNIEnv&, jni::jboolean updateClasses) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "Update style property. Update classes: " + std::to_string(updateClasses));
-
         //Update the style only if attached
         if (ownedLayer == nullptr) {
             Update flags = mbgl::Update::RecalculateStyle;
@@ -89,7 +79,6 @@ namespace android {
     void Layer::setFilter(jni::JNIEnv& env, jni::Array<jni::Object<>> jfilter) {
         using namespace mbgl::style;
         using namespace mbgl::style::conversion;
-        mbgl::Log::Debug(mbgl::Event::JNI, "Set filter");
 
         Value wrapped(env, jfilter);
         Filter filter;
@@ -118,7 +107,6 @@ namespace android {
         using namespace mbgl::style;
 
         std::string layerId = jni::Make<std::string>(env, sourceLayer);
-        mbgl::Log::Debug(mbgl::Event::JNI, "Set source layer: " + layerId);
 
         if (layer.is<FillLayer>()) {
             layer.as<FillLayer>()->setSourceLayer(layerId);
@@ -133,11 +121,30 @@ namespace android {
         }
     }
 
+    jni::jfloat Layer::getMinZoom(jni::JNIEnv&){
+        return layer.getMinZoom();
+    }
+
+    jni::jfloat Layer::getMaxZoom(jni::JNIEnv&) {
+        return layer.getMaxZoom();
+    }
+
+    void Layer::setMinZoom(jni::JNIEnv&, jni::jfloat zoom) {
+        layer.setMinZoom(zoom);
+    }
+
+    void Layer::setMaxZoom(jni::JNIEnv&, jni::jfloat zoom) {
+        layer.setMaxZoom(zoom);
+    }
+
+    jni::Object<jni::ObjectTag> Layer::getVisibility(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return jni::Object<jni::ObjectTag>(*convert<jni::jobject*>(env, layer.getVisibility()));
+    }
+
     jni::Class<Layer> Layer::javaClass;
 
     void Layer::registerNative(jni::JNIEnv& env) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "Registering native base layer");
-
         //Lookup the class
         Layer::javaClass = *jni::Class<Layer>::Find(env).NewGlobalRef(env).release();
 
@@ -150,9 +157,15 @@ namespace android {
             METHOD(&Layer::setPaintProperty, "nativeSetPaintProperty"),
             METHOD(&Layer::updateStyle, "nativeUpdateStyle"),
             METHOD(&Layer::setFilter, "nativeSetFilter"),
-            METHOD(&Layer::setSourceLayer, "nativeSetSourceLayer")
+            METHOD(&Layer::setSourceLayer, "nativeSetSourceLayer"),
+            METHOD(&Layer::getMinZoom, "nativeGetMinZoom"),
+            METHOD(&Layer::getMaxZoom, "nativeGetMaxZoom"),
+            METHOD(&Layer::setMinZoom, "nativeSetMinZoom"),
+            METHOD(&Layer::setMaxZoom, "nativeSetMaxZoom"),
+            METHOD(&Layer::getVisibility, "nativeGetVisibility")
         );
 
     }
-}
-}
\ No newline at end of file
+
+} //android
+} //mbgl
\ No newline at end of file
diff --git a/platform/android/src/style/layers/layer.cpp.ejs b/platform/android/src/style/layers/layer.cpp.ejs
new file mode 100644
index 0000000000..68dd27b801
--- /dev/null
+++ b/platform/android/src/style/layers/layer.cpp.ejs
@@ -0,0 +1,69 @@
+<%
+  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`.
+
+#include "<%- type %>_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+
+namespace mbgl {
+namespace android {
+
+<% if (type === 'background') { -%>
+    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(jni::JNIEnv& env, jni::String layerId)
+        : Layer(env, std::make_unique<mbgl::style::<%- camelize(type) %>Layer>(jni::Make<std::string>(env, layerId))) {
+<% } else { -%>
+    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(jni::JNIEnv& env, jni::String layerId, jni::String sourceId)
+        : Layer(env, std::make_unique<mbgl::style::<%- camelize(type) %>Layer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+<% } -%>
+    }
+
+    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(mbgl::Map& map, mbgl::style::<%- camelize(type) %>Layer& coreLayer)
+        : Layer(map, coreLayer) {
+    }
+
+    <%- camelize(type) %>Layer::~<%- camelize(type) %>Layer() = default;
+
+    // Property getters
+
+<% for (const property of properties) { -%>
+    jni::Object<jni::ObjectTag> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::<%- camelize(type) %>Layer>()-><%- camelize(type) %>Layer::get<%- camelize(property.name) %>());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+<% } -%>
+    jni::Class<<%- camelize(type) %>Layer> <%- camelize(type) %>Layer::javaClass;
+
+    jni::jobject* <%- camelize(type) %>Layer::createJavaPeer(jni::JNIEnv& env) {
+        static auto constructor = <%- camelize(type) %>Layer::javaClass.template GetConstructor<jni::jlong>(env);
+        return <%- camelize(type) %>Layer::javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+    }
+
+    void <%- camelize(type) %>Layer::registerNative(jni::JNIEnv& env) {
+        //Lookup the class
+        <%- camelize(type) %>Layer::javaClass = *jni::Class<<%- camelize(type) %>Layer>::Find(env).NewGlobalRef(env).release();
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        //Register the peer
+        jni::RegisterNativePeer<<%- camelize(type) %>Layer>(
+            env, <%- camelize(type) %>Layer::javaClass, "nativePtr",
+<% if (type === 'background') { -%>
+            std::make_unique<<%- camelize(type) %>Layer, JNIEnv&, jni::String>,
+<% } else { -%>
+            std::make_unique<<%- camelize(type) %>Layer, JNIEnv&, jni::String, jni::String>,
+<% } -%>
+            "initialize",
+            "finalize",<% for(var i = 0; i < properties.length; i++) {%>
+            METHOD(&<%- camelize(type) %>Layer::get<%- camelize(properties[i].name) %>, "nativeGet<%- camelize(properties[i].name) %>")<% if(i != (properties.length -1)) {-%>,<% } -%>
+<% } -%>);
+    }
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/layers/layer.hpp b/platform/android/src/style/layers/layer.hpp
index 8b3487551b..37eb34cdd7 100644
--- a/platform/android/src/style/layers/layer.hpp
+++ b/platform/android/src/style/layers/layer.hpp
@@ -45,12 +45,26 @@ public:
 
     void updateStyle(jni::JNIEnv&, jni::jboolean updateClasses);
 
+    //Zoom
+
+    jni::jfloat getMinZoom(jni::JNIEnv&);
+
+    jni::jfloat getMaxZoom(jni::JNIEnv&);
+
+    void setMinZoom(jni::JNIEnv&, jni::jfloat zoom);
+
+    void setMaxZoom(jni::JNIEnv&, jni::jfloat zoom);
+
     /* common properties, but not shared by all */
 
     void setFilter(jni::JNIEnv& env, jni::Array<jni::Object<>> jfilter);
 
     void setSourceLayer(jni::JNIEnv& env, jni::String sourceLayer);
 
+    //Property getters
+
+    jni::Object<jni::ObjectTag> getVisibility(jni::JNIEnv&);
+
 protected:
     std::unique_ptr<mbgl::style::Layer> ownedLayer;
     mbgl::style::Layer& layer;
diff --git a/platform/android/src/style/layers/layer.hpp.ejs b/platform/android/src/style/layers/layer.hpp.ejs
new file mode 100644
index 0000000000..826e133fca
--- /dev/null
+++ b/platform/android/src/style/layers/layer.hpp.ejs
@@ -0,0 +1,45 @@
+<%
+  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`.
+
+#pragma once
+
+#include "layer.hpp"
+#include <mbgl/style/layers/<%- type %>_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class <%- camelize(type) %>Layer : public Layer {
+public:
+
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/<%- camelize(type) %>Layer"; };
+
+    static jni::Class<<%- camelize(type) %>Layer> javaClass;
+
+    static void registerNative(jni::JNIEnv&);
+
+<% if (type === 'background') { -%>
+    <%- camelize(type) %>Layer(jni::JNIEnv&, jni::String);
+<% } else { -%>
+    <%- camelize(type) %>Layer(jni::JNIEnv&, jni::String, jni::String);
+<% } -%>
+
+    <%- camelize(type) %>Layer(mbgl::Map&, mbgl::style::<%- camelize(type) %>Layer&);
+
+    ~<%- camelize(type) %>Layer();
+
+    // Property getters
+<% for (const property of properties) { -%>
+    jni::Object<jni::ObjectTag> get<%- camelize(property.name) %>(jni::JNIEnv&);
+
+<% } -%>
+    jni::jobject* createJavaPeer(jni::JNIEnv&);
+
+}; // class <%- camelize(type) %>Layer
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/layers/layers.cpp b/platform/android/src/style/layers/layers.cpp
index 4ccdc829f2..57dbf6f4b1 100644
--- a/platform/android/src/style/layers/layers.cpp
+++ b/platform/android/src/style/layers/layers.cpp
@@ -6,6 +6,7 @@
 #include <mbgl/style/layers/line_layer.hpp>
 #include <mbgl/style/layers/raster_layer.hpp>
 #include <mbgl/style/layers/symbol_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
 
 #include "background_layer.hpp"
 #include "circle_layer.hpp"
@@ -13,6 +14,7 @@
 #include "line_layer.hpp"
 #include "raster_layer.hpp"
 #include "symbol_layer.hpp"
+#include "custom_layer.hpp"
 
 namespace mbgl {
 namespace android {
@@ -31,6 +33,8 @@ Layer* initializeLayerPeer(mbgl::Map& map, mbgl::style::Layer& coreLayer) {
             layer = new RasterLayer(map, *coreLayer.as<mbgl::style::RasterLayer>());
     } else if (coreLayer.is<mbgl::style::SymbolLayer>()) {
         layer = new SymbolLayer(map, *coreLayer.as<mbgl::style::SymbolLayer>());
+    } else if (coreLayer.is<mbgl::style::CustomLayer>()) {
+        layer = new CustomLayer(map, *coreLayer.as<mbgl::style::CustomLayer>());
     } else {
         throw new std::runtime_error("Layer type not implemented");
     }
@@ -42,7 +46,6 @@ jni::jobject* createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style:
     std::unique_ptr<Layer> peerLayer = std::unique_ptr<Layer>(initializeLayerPeer(map, coreLayer));
     jni::jobject* result = peerLayer->createJavaPeer(env);
     peerLayer.release();
-
     return result;
 }
 
@@ -54,7 +57,8 @@ void registerNativeLayers(jni::JNIEnv& env) {
     LineLayer::registerNative(env);
     RasterLayer::registerNative(env);
     SymbolLayer::registerNative(env);
+    CustomLayer::registerNative(env);
 }
 
-}
-}
\ No newline at end of file
+} //android
+} //mbgl
\ No newline at end of file
diff --git a/platform/android/src/style/layers/line_layer.cpp b/platform/android/src/style/layers/line_layer.cpp
index fdf2af7973..91d3e4a1cd 100644
--- a/platform/android/src/style/layers/line_layer.cpp
+++ b/platform/android/src/style/layers/line_layer.cpp
@@ -4,25 +4,107 @@
 
 #include <string>
 
-//XXX
-#include <mbgl/platform/log.hpp>
+#include "../conversion/property_value.hpp"
 
 namespace mbgl {
 namespace android {
 
     LineLayer::LineLayer(jni::JNIEnv& env, jni::String layerId, jni::String sourceId)
         : Layer(env, std::make_unique<mbgl::style::LineLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "LineLayer constructed, owning reference");
     }
 
     LineLayer::LineLayer(mbgl::Map& map, mbgl::style::LineLayer& coreLayer)
         : Layer(map, coreLayer) {
-
-        mbgl::Log::Debug(mbgl::Event::JNI, "LineLayer Non-owning reference constructor");
     }
 
     LineLayer::~LineLayer() = default;
 
+    // Property getters
+
+    jni::Object<jni::ObjectTag> LineLayer::getLineCap(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineCap());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> LineLayer::getLineJoin(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineJoin());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> LineLayer::getLineMiterLimit(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineMiterLimit());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> LineLayer::getLineRoundLimit(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineRoundLimit());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> LineLayer::getLineOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineOpacity());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> LineLayer::getLineColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineColor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> LineLayer::getLineTranslate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineTranslate());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> LineLayer::getLineTranslateAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineTranslateAnchor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> LineLayer::getLineWidth(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineWidth());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> LineLayer::getLineGapWidth(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineGapWidth());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> LineLayer::getLineOffset(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineOffset());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> LineLayer::getLineBlur(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineBlur());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> LineLayer::getLineDasharray(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineDasharray());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> LineLayer::getLinePattern(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLinePattern());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
     jni::Class<LineLayer> LineLayer::javaClass;
 
     jni::jobject* LineLayer::createJavaPeer(jni::JNIEnv& env) {
@@ -31,8 +113,6 @@ namespace android {
     }
 
     void LineLayer::registerNative(jni::JNIEnv& env) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "Registering native background layer");
-
         //Lookup the class
         LineLayer::javaClass = *jni::Class<LineLayer>::Find(env).NewGlobalRef(env).release();
 
@@ -43,9 +123,21 @@ namespace android {
             env, LineLayer::javaClass, "nativePtr",
             std::make_unique<LineLayer, JNIEnv&, jni::String, jni::String>,
             "initialize",
-            "finalize"
-        );
-
+            "finalize",
+            METHOD(&LineLayer::getLineCap, "nativeGetLineCap"),
+            METHOD(&LineLayer::getLineJoin, "nativeGetLineJoin"),
+            METHOD(&LineLayer::getLineMiterLimit, "nativeGetLineMiterLimit"),
+            METHOD(&LineLayer::getLineRoundLimit, "nativeGetLineRoundLimit"),
+            METHOD(&LineLayer::getLineOpacity, "nativeGetLineOpacity"),
+            METHOD(&LineLayer::getLineColor, "nativeGetLineColor"),
+            METHOD(&LineLayer::getLineTranslate, "nativeGetLineTranslate"),
+            METHOD(&LineLayer::getLineTranslateAnchor, "nativeGetLineTranslateAnchor"),
+            METHOD(&LineLayer::getLineWidth, "nativeGetLineWidth"),
+            METHOD(&LineLayer::getLineGapWidth, "nativeGetLineGapWidth"),
+            METHOD(&LineLayer::getLineOffset, "nativeGetLineOffset"),
+            METHOD(&LineLayer::getLineBlur, "nativeGetLineBlur"),
+            METHOD(&LineLayer::getLineDasharray, "nativeGetLineDasharray"),
+            METHOD(&LineLayer::getLinePattern, "nativeGetLinePattern"));
     }
 
 } // namespace android
diff --git a/platform/android/src/style/layers/line_layer.hpp b/platform/android/src/style/layers/line_layer.hpp
index cb53d82940..da9b564325 100644
--- a/platform/android/src/style/layers/line_layer.hpp
+++ b/platform/android/src/style/layers/line_layer.hpp
@@ -24,8 +24,38 @@ public:
 
     ~LineLayer();
 
+    // Property getters
+    jni::Object<jni::ObjectTag> getLineCap(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getLineJoin(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getLineMiterLimit(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getLineRoundLimit(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getLineOpacity(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getLineColor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getLineTranslate(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getLineTranslateAnchor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getLineWidth(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getLineGapWidth(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getLineOffset(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getLineBlur(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getLineDasharray(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getLinePattern(jni::JNIEnv&);
+
     jni::jobject* createJavaPeer(jni::JNIEnv&);
-};
+
+}; // class LineLayer
 
 } // namespace android
 } // namespace mbgl
diff --git a/platform/android/src/style/layers/raster_layer.cpp b/platform/android/src/style/layers/raster_layer.cpp
index 3da246e128..da78ccb8e3 100644
--- a/platform/android/src/style/layers/raster_layer.cpp
+++ b/platform/android/src/style/layers/raster_layer.cpp
@@ -4,25 +4,65 @@
 
 #include <string>
 
-//XXX
-#include <mbgl/platform/log.hpp>
+#include "../conversion/property_value.hpp"
 
 namespace mbgl {
 namespace android {
 
     RasterLayer::RasterLayer(jni::JNIEnv& env, jni::String layerId, jni::String sourceId)
         : Layer(env, std::make_unique<mbgl::style::RasterLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "RasterLayer constructed, owning reference");
     }
 
     RasterLayer::RasterLayer(mbgl::Map& map, mbgl::style::RasterLayer& coreLayer)
         : Layer(map, coreLayer) {
-
-        mbgl::Log::Debug(mbgl::Event::JNI, "RasterLayer Non-owning reference constructor");
     }
 
     RasterLayer::~RasterLayer() = default;
 
+    // Property getters
+
+    jni::Object<jni::ObjectTag> RasterLayer::getRasterOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterOpacity());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> RasterLayer::getRasterHueRotate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterHueRotate());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> RasterLayer::getRasterBrightnessMin(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterBrightnessMin());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> RasterLayer::getRasterBrightnessMax(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterBrightnessMax());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> RasterLayer::getRasterSaturation(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterSaturation());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> RasterLayer::getRasterContrast(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterContrast());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> RasterLayer::getRasterFadeDuration(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterFadeDuration());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
     jni::Class<RasterLayer> RasterLayer::javaClass;
 
     jni::jobject* RasterLayer::createJavaPeer(jni::JNIEnv& env) {
@@ -31,8 +71,6 @@ namespace android {
     }
 
     void RasterLayer::registerNative(jni::JNIEnv& env) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "Registering native background layer");
-
         //Lookup the class
         RasterLayer::javaClass = *jni::Class<RasterLayer>::Find(env).NewGlobalRef(env).release();
 
@@ -43,9 +81,14 @@ namespace android {
             env, RasterLayer::javaClass, "nativePtr",
             std::make_unique<RasterLayer, JNIEnv&, jni::String, jni::String>,
             "initialize",
-            "finalize"
-        );
-
+            "finalize",
+            METHOD(&RasterLayer::getRasterOpacity, "nativeGetRasterOpacity"),
+            METHOD(&RasterLayer::getRasterHueRotate, "nativeGetRasterHueRotate"),
+            METHOD(&RasterLayer::getRasterBrightnessMin, "nativeGetRasterBrightnessMin"),
+            METHOD(&RasterLayer::getRasterBrightnessMax, "nativeGetRasterBrightnessMax"),
+            METHOD(&RasterLayer::getRasterSaturation, "nativeGetRasterSaturation"),
+            METHOD(&RasterLayer::getRasterContrast, "nativeGetRasterContrast"),
+            METHOD(&RasterLayer::getRasterFadeDuration, "nativeGetRasterFadeDuration"));
     }
 
 } // namespace android
diff --git a/platform/android/src/style/layers/raster_layer.hpp b/platform/android/src/style/layers/raster_layer.hpp
index f77771631c..e59cd05f87 100644
--- a/platform/android/src/style/layers/raster_layer.hpp
+++ b/platform/android/src/style/layers/raster_layer.hpp
@@ -24,8 +24,24 @@ public:
 
     ~RasterLayer();
 
+    // Property getters
+    jni::Object<jni::ObjectTag> getRasterOpacity(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getRasterHueRotate(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getRasterBrightnessMin(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getRasterBrightnessMax(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getRasterSaturation(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getRasterContrast(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getRasterFadeDuration(jni::JNIEnv&);
+
     jni::jobject* createJavaPeer(jni::JNIEnv&);
-};
+
+}; // class RasterLayer
 
 } // namespace android
 } // namespace mbgl
diff --git a/platform/android/src/style/layers/symbol_layer.cpp b/platform/android/src/style/layers/symbol_layer.cpp
index 5de08f6511..fd69b6591f 100644
--- a/platform/android/src/style/layers/symbol_layer.cpp
+++ b/platform/android/src/style/layers/symbol_layer.cpp
@@ -4,25 +4,311 @@
 
 #include <string>
 
-//XXX
-#include <mbgl/platform/log.hpp>
+#include "../conversion/property_value.hpp"
 
 namespace mbgl {
 namespace android {
 
     SymbolLayer::SymbolLayer(jni::JNIEnv& env, jni::String layerId, jni::String sourceId)
         : Layer(env, std::make_unique<mbgl::style::SymbolLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "SymbolLayer constructed, owning reference");
     }
 
     SymbolLayer::SymbolLayer(mbgl::Map& map, mbgl::style::SymbolLayer& coreLayer)
         : Layer(map, coreLayer) {
-
-        mbgl::Log::Debug(mbgl::Event::JNI, "SymbolLayer Non-owning reference constructor");
     }
 
     SymbolLayer::~SymbolLayer() = default;
 
+    // Property getters
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getSymbolPlacement(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getSymbolPlacement());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getSymbolSpacing(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getSymbolSpacing());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getSymbolAvoidEdges(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getSymbolAvoidEdges());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconAllowOverlap(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconAllowOverlap());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconIgnorePlacement(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconIgnorePlacement());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconOptional(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconOptional());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconRotationAlignment(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconRotationAlignment());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconSize(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconSize());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconTextFit(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconTextFit());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconTextFitPadding(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconTextFitPadding());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconImage(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconImage());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconRotate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconRotate());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconPadding(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconPadding());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconKeepUpright(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconKeepUpright());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconOffset(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconOffset());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextPitchAlignment(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextPitchAlignment());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextRotationAlignment(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextRotationAlignment());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextField(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextField());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextFont(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextFont());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextSize(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextSize());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextMaxWidth(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextMaxWidth());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextLineHeight(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextLineHeight());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextLetterSpacing(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextLetterSpacing());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextJustify(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextJustify());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextAnchor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextMaxAngle(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextMaxAngle());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextRotate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextRotate());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextPadding(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextPadding());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextKeepUpright(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextKeepUpright());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextTransform(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextTransform());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextOffset(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextOffset());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextAllowOverlap(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextAllowOverlap());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextIgnorePlacement(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextIgnorePlacement());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextOptional(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextOptional());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconOpacity());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconColor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconHaloColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconHaloColor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconHaloWidth(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconHaloWidth());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconHaloBlur(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconHaloBlur());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconTranslate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconTranslate());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getIconTranslateAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconTranslateAnchor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextOpacity());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextColor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextHaloColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextHaloColor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextHaloWidth(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextHaloWidth());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextHaloBlur(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextHaloBlur());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextTranslate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextTranslate());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
+    jni::Object<jni::ObjectTag> SymbolLayer::getTextTranslateAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextTranslateAnchor());
+        return jni::Object<jni::ObjectTag>(*converted);
+    }
+
     jni::Class<SymbolLayer> SymbolLayer::javaClass;
 
     jni::jobject* SymbolLayer::createJavaPeer(jni::JNIEnv& env) {
@@ -31,8 +317,6 @@ namespace android {
     }
 
     void SymbolLayer::registerNative(jni::JNIEnv& env) {
-        mbgl::Log::Debug(mbgl::Event::JNI, "Registering native background layer");
-
         //Lookup the class
         SymbolLayer::javaClass = *jni::Class<SymbolLayer>::Find(env).NewGlobalRef(env).release();
 
@@ -43,9 +327,55 @@ namespace android {
             env, SymbolLayer::javaClass, "nativePtr",
             std::make_unique<SymbolLayer, JNIEnv&, jni::String, jni::String>,
             "initialize",
-            "finalize"
-        );
-
+            "finalize",
+            METHOD(&SymbolLayer::getSymbolPlacement, "nativeGetSymbolPlacement"),
+            METHOD(&SymbolLayer::getSymbolSpacing, "nativeGetSymbolSpacing"),
+            METHOD(&SymbolLayer::getSymbolAvoidEdges, "nativeGetSymbolAvoidEdges"),
+            METHOD(&SymbolLayer::getIconAllowOverlap, "nativeGetIconAllowOverlap"),
+            METHOD(&SymbolLayer::getIconIgnorePlacement, "nativeGetIconIgnorePlacement"),
+            METHOD(&SymbolLayer::getIconOptional, "nativeGetIconOptional"),
+            METHOD(&SymbolLayer::getIconRotationAlignment, "nativeGetIconRotationAlignment"),
+            METHOD(&SymbolLayer::getIconSize, "nativeGetIconSize"),
+            METHOD(&SymbolLayer::getIconTextFit, "nativeGetIconTextFit"),
+            METHOD(&SymbolLayer::getIconTextFitPadding, "nativeGetIconTextFitPadding"),
+            METHOD(&SymbolLayer::getIconImage, "nativeGetIconImage"),
+            METHOD(&SymbolLayer::getIconRotate, "nativeGetIconRotate"),
+            METHOD(&SymbolLayer::getIconPadding, "nativeGetIconPadding"),
+            METHOD(&SymbolLayer::getIconKeepUpright, "nativeGetIconKeepUpright"),
+            METHOD(&SymbolLayer::getIconOffset, "nativeGetIconOffset"),
+            METHOD(&SymbolLayer::getTextPitchAlignment, "nativeGetTextPitchAlignment"),
+            METHOD(&SymbolLayer::getTextRotationAlignment, "nativeGetTextRotationAlignment"),
+            METHOD(&SymbolLayer::getTextField, "nativeGetTextField"),
+            METHOD(&SymbolLayer::getTextFont, "nativeGetTextFont"),
+            METHOD(&SymbolLayer::getTextSize, "nativeGetTextSize"),
+            METHOD(&SymbolLayer::getTextMaxWidth, "nativeGetTextMaxWidth"),
+            METHOD(&SymbolLayer::getTextLineHeight, "nativeGetTextLineHeight"),
+            METHOD(&SymbolLayer::getTextLetterSpacing, "nativeGetTextLetterSpacing"),
+            METHOD(&SymbolLayer::getTextJustify, "nativeGetTextJustify"),
+            METHOD(&SymbolLayer::getTextAnchor, "nativeGetTextAnchor"),
+            METHOD(&SymbolLayer::getTextMaxAngle, "nativeGetTextMaxAngle"),
+            METHOD(&SymbolLayer::getTextRotate, "nativeGetTextRotate"),
+            METHOD(&SymbolLayer::getTextPadding, "nativeGetTextPadding"),
+            METHOD(&SymbolLayer::getTextKeepUpright, "nativeGetTextKeepUpright"),
+            METHOD(&SymbolLayer::getTextTransform, "nativeGetTextTransform"),
+            METHOD(&SymbolLayer::getTextOffset, "nativeGetTextOffset"),
+            METHOD(&SymbolLayer::getTextAllowOverlap, "nativeGetTextAllowOverlap"),
+            METHOD(&SymbolLayer::getTextIgnorePlacement, "nativeGetTextIgnorePlacement"),
+            METHOD(&SymbolLayer::getTextOptional, "nativeGetTextOptional"),
+            METHOD(&SymbolLayer::getIconOpacity, "nativeGetIconOpacity"),
+            METHOD(&SymbolLayer::getIconColor, "nativeGetIconColor"),
+            METHOD(&SymbolLayer::getIconHaloColor, "nativeGetIconHaloColor"),
+            METHOD(&SymbolLayer::getIconHaloWidth, "nativeGetIconHaloWidth"),
+            METHOD(&SymbolLayer::getIconHaloBlur, "nativeGetIconHaloBlur"),
+            METHOD(&SymbolLayer::getIconTranslate, "nativeGetIconTranslate"),
+            METHOD(&SymbolLayer::getIconTranslateAnchor, "nativeGetIconTranslateAnchor"),
+            METHOD(&SymbolLayer::getTextOpacity, "nativeGetTextOpacity"),
+            METHOD(&SymbolLayer::getTextColor, "nativeGetTextColor"),
+            METHOD(&SymbolLayer::getTextHaloColor, "nativeGetTextHaloColor"),
+            METHOD(&SymbolLayer::getTextHaloWidth, "nativeGetTextHaloWidth"),
+            METHOD(&SymbolLayer::getTextHaloBlur, "nativeGetTextHaloBlur"),
+            METHOD(&SymbolLayer::getTextTranslate, "nativeGetTextTranslate"),
+            METHOD(&SymbolLayer::getTextTranslateAnchor, "nativeGetTextTranslateAnchor"));
     }
 
 } // namespace android
diff --git a/platform/android/src/style/layers/symbol_layer.hpp b/platform/android/src/style/layers/symbol_layer.hpp
index 3f3b0e1fe6..f5165327bf 100644
--- a/platform/android/src/style/layers/symbol_layer.hpp
+++ b/platform/android/src/style/layers/symbol_layer.hpp
@@ -24,8 +24,106 @@ public:
 
     ~SymbolLayer();
 
+    // Property getters
+    jni::Object<jni::ObjectTag> getSymbolPlacement(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getSymbolSpacing(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getSymbolAvoidEdges(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconAllowOverlap(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconIgnorePlacement(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconOptional(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconRotationAlignment(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconSize(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconTextFit(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconTextFitPadding(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconImage(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconRotate(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconPadding(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconKeepUpright(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconOffset(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextPitchAlignment(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextRotationAlignment(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextField(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextFont(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextSize(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextMaxWidth(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextLineHeight(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextLetterSpacing(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextJustify(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextAnchor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextMaxAngle(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextRotate(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextPadding(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextKeepUpright(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextTransform(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextOffset(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextAllowOverlap(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextIgnorePlacement(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextOptional(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconOpacity(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconColor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconHaloColor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconHaloWidth(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconHaloBlur(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconTranslate(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getIconTranslateAnchor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextOpacity(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextColor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextHaloColor(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextHaloWidth(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextHaloBlur(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextTranslate(jni::JNIEnv&);
+
+    jni::Object<jni::ObjectTag> getTextTranslateAnchor(jni::JNIEnv&);
+
     jni::jobject* createJavaPeer(jni::JNIEnv&);
-};
+
+}; // class SymbolLayer
 
 } // namespace android
 } // namespace mbgl