Move JNI bindings code from mapbox-gl-native to this repo. (#301)

MapboxGLAndroidSDK/src/cpp/style/android_conversion.hpp

@@ -0,0 +1,148 @@
+#pragma once
+
+#include "value.hpp"
+
+#include <mbgl/util/feature.hpp>
+#include <mbgl/util/logging.hpp>
+#include <mbgl/util/optional.hpp>
+#include <mbgl/style/conversion/geojson.hpp>
+#include <mbgl/style/conversion_impl.hpp>
+
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+template <>
+class ConversionTraits<mbgl::android::Value> {
+public:
+    static bool isUndefined(const mbgl::android::Value& value) {
+        return value.isNull();
+    }
+
+    static bool isArray(const mbgl::android::Value& value) {
+        return value.isArray();
+    }
+
+    static bool isObject(const mbgl::android::Value& value) {
+        return value.isObject();
+    }
+
+    static std::size_t arrayLength(const mbgl::android::Value& value) {
+        return value.getLength();;
+    }
+
+    static mbgl::android::Value arrayMember(const mbgl::android::Value& value, std::size_t i) {
+        return value.get(i);
+    }
+
+    static optional<mbgl::android::Value> objectMember(const mbgl::android::Value& value, const char* key) {
+        mbgl::android::Value member = value.get(key);
+        if (!member.isNull()) {
+            return member;
+        } else {
+            return {};
+        }
+    }
+
+    template <class Fn>
+    static optional<Error> eachMember(const mbgl::android::Value& value, Fn&& fn) {
+        assert(value.isObject());
+        mbgl::android::Value keys = value.keyArray();
+        std::size_t length = arrayLength(keys);
+        for(std::size_t i = 0; i < length; ++i){
+            const auto k = keys.get(i).toString();
+            auto v = value.get(k.c_str());
+            optional<Error> result = fn(k, std::move(v));
+            if (result) {
+                return result;
+            }
+        }
+        return {};
+    }
+
+    static optional<bool> toBool(const mbgl::android::Value& value) {
+        if (value.isBool()) {
+            return value.toBool();
+        } else {
+            return {};
+        }
+    }
+
+    static optional<float> toNumber(const mbgl::android::Value& value) {
+        if (value.isNumber()) {
+            auto num = value.toFloat();
+            return num;
+        } else {
+            return {};
+        }
+    }
+
+    static optional<double> toDouble(const mbgl::android::Value& value) {
+        if (value.isNumber()) {
+            return value.toDouble();
+        } else {
+            return {};
+        }
+    }
+
+    static optional<std::string> toString(const mbgl::android::Value& value) {
+        if (value.isString()) {
+            return value.toString();
+        } else {
+            return {};
+        }
+    }
+
+    static optional<Value> toValue(const mbgl::android::Value& value) {
+        if (value.isNull()) {
+            return {};
+        } else if (value.isBool()) {
+            return { value.toBool() };
+        } else if (value.isString()) {
+            return { value.toString() };
+        } else if (value.isNumber()) {
+            return { value.toDouble() };
+        } else {
+            return {};
+        }
+    }
+
+    static optional<GeoJSON> toGeoJSON(const mbgl::android::Value &value, Error &error) {
+        if (value.isNull()) {
+            error = { "no json data found" };
+            return {};
+        }
+
+        if (value.isString()) {
+            return parseGeoJSON(value.toString(), error);
+        }
+
+        if (value.isObject()) {
+            mbgl::android::Value keys = value.keyArray();
+            std::size_t length = arrayLength(keys);
+            for (std::size_t i = 0; i < length; ++i) {
+                if (keys.get(i).toString() == "json") {
+                    auto v = value.get("json");
+                    if (v.isString()) {
+                        return parseGeoJSON(v.toString(), error);
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+        error = {"no json data found"};
+        return {};
+    }
+};
+
+template <class T, class...Args>
+optional<T> convert(mbgl::android::Value&& value, Error& error, Args&&...args) {
+    return convert<T>(Convertible(std::move(value)), error, std::forward<Args>(args)...);
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/conversion/filter.cpp

@@ -0,0 +1,26 @@
+#include "filter.hpp"
+#include "../android_conversion.hpp"
+
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/filter.hpp>
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+optional<mbgl::style::Filter> toFilter(jni::JNIEnv& env, const jni::Array<jni::Object<>>& jfilter) {
+    mbgl::optional<mbgl::style::Filter> filter;
+    if (jfilter) {
+      mbgl::style::conversion::Error error;
+      auto converted = mbgl::style::conversion::convert<mbgl::style::Filter>(Value(env, jfilter), error);
+      if (!converted) {
+          mbgl::Log::Error(mbgl::Event::JNI, "Error converting filter: " + error.message);
+      }
+      filter = std::move(*converted);
+    }
+    return filter;
+}
+
+} // namespace conversion
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/conversion/filter.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <mbgl/style/filter.hpp>
+#include <mbgl/util/optional.hpp>
+
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+optional<mbgl::style::Filter> toFilter(jni::JNIEnv&, const jni::Array<jni::Object<>>&);
+
+} // namespace conversion
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/conversion/position.cpp

@@ -0,0 +1,24 @@
+#include "position.hpp"
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+Result<jni::Local<jni::Object<Position>>> Converter<jni::Local<jni::Object<Position>>, mbgl::style::Position>::operator()(jni::JNIEnv &env, const mbgl::style::Position &value) const {
+    std::array<float, 3> cartPosition = value.getSpherical();
+    return Position::fromPosition(env, cartPosition[0], cartPosition[1], cartPosition[2]);
+}
+
+Result<mbgl::style::Position> Converter<mbgl::style::Position, jni::Object<Position>>::operator()(jni::JNIEnv &env, const jni::Object<Position> &value) const {
+    float radialCoordinate = Position::getRadialCoordinate(env, value);
+    float azimuthalAngle = Position::getAzimuthalAngle(env, value);
+    float polarAngle = Position::getPolarAngle(env, value);
+    std::array<float, 3> cartPosition {{radialCoordinate, azimuthalAngle, polarAngle}};
+    mbgl::style::Position position{};
+    position.set(cartPosition);
+    return position;
+}
+
+}
+}
+}

MapboxGLAndroidSDK/src/cpp/style/conversion/position.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "../../conversion/conversion.hpp"
+#include "../position.hpp"
+
+#include <mbgl/style/position.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+template <>
+struct Converter<jni::Local<jni::Object<Position>>, mbgl::style::Position> {
+    Result<jni::Local<jni::Object<Position>>> operator()(jni::JNIEnv &env, const mbgl::style::Position &value) const;
+};
+
+template <>
+struct Converter<mbgl::style::Position, jni::Object<Position>> {
+    Result<mbgl::style::Position> operator()(jni::JNIEnv &env, const jni::Object<Position> &value) const;
+};
+
+}
+}
+}

MapboxGLAndroidSDK/src/cpp/style/conversion/property_expression.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "../../conversion/conversion.hpp"
+#include "../../gson/json_element.hpp"
+
+#include <mbgl/style/property_expression.hpp>
+
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+template <class T>
+struct Converter<jni::Local<jni::Object<android::gson::JsonElement>>, mbgl::style::PropertyExpression<T>> {
+    Result<jni::Local<jni::Object<android::gson::JsonElement>>> operator()(jni::JNIEnv& env, const mbgl::style::PropertyExpression<T>& value) const {
+        return gson::JsonElement::New(env, value.getExpression().serialize());
+    }
+};
+
+} // namespace conversion
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/conversion/property_value.hpp

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <mbgl/style/color_ramp_property_value.hpp>
+#include <mbgl/style/property_value.hpp>
+
+#include "../../conversion/conversion.hpp"
+#include "../../conversion/constant.hpp"
+#include "property_expression.hpp"
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+/**
+ * Conversion from core property value types to Java property value types
+ */
+template <typename T>
+class PropertyValueEvaluator {
+public:
+    PropertyValueEvaluator(jni::JNIEnv& _env) : env(_env) {}
+
+    jni::Local<jni::Object<>> operator()(const mbgl::style::Undefined) const {
+        return jni::Local<jni::Object<>>(env, nullptr);
+    }
+
+    jni::Local<jni::Object<>> operator()(const T& value) const {
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, value));
+    }
+
+    jni::Local<jni::Object<>> operator()(const mbgl::style::PropertyExpression<T>& value) const {
+        return std::move(*convert<jni::Local<jni::Object<android::gson::JsonElement>>>(env, value));
+    }
+
+private:
+    jni::JNIEnv& env;
+};
+
+/**
+ * Convert core property values to java
+ */
+template <class T>
+struct Converter<jni::Local<jni::Object<>>, mbgl::style::PropertyValue<T>> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const mbgl::style::PropertyValue<T>& value) const {
+        PropertyValueEvaluator<T> evaluator(env);
+        return value.evaluate(evaluator);
+    }
+};
+
+/**
+ * Convert core heat map color property value to java
+ */
+template <>
+struct Converter<jni::Local<jni::Object<>>, mbgl::style::ColorRampPropertyValue> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const mbgl::style::ColorRampPropertyValue& value) const {
+        PropertyValueEvaluator<mbgl::style::ColorRampPropertyValue> evaluator(env);
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, value.evaluate(evaluator)));
+    }
+};
+
+} // namespace conversion
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/conversion/transition_options.cpp

@@ -0,0 +1,17 @@
+#include "transition_options.hpp"
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+Result<jni::Local<jni::Object<TransitionOptions>>> Converter<jni::Local<jni::Object<TransitionOptions>>, mbgl::style::TransitionOptions>::operator()(jni::JNIEnv& env, const mbgl::style::TransitionOptions& value) const {
+    return TransitionOptions::fromTransitionOptions(env,
+        std::chrono::duration_cast<std::chrono::milliseconds>(value.duration.value_or(mbgl::Duration::zero())).count(),
+        std::chrono::duration_cast<std::chrono::milliseconds>(value.delay.value_or(mbgl::Duration::zero())).count(),
+        (jboolean) value.enablePlacementTransitions
+    );
+}
+
+}
+}
+}

MapboxGLAndroidSDK/src/cpp/style/conversion/transition_options.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "../../conversion/conversion.hpp"
+#include "../transition_options.hpp"
+
+#include <mbgl/style/transition_options.hpp>
+
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+template<>
+struct Converter<jni::Local<jni::Object<TransitionOptions>>, mbgl::style::TransitionOptions> {
+    Result<jni::Local<jni::Object<TransitionOptions>>> operator()(jni::JNIEnv&, const mbgl::style::TransitionOptions&) const;
+};
+
+}
+}
+}

MapboxGLAndroidSDK/src/cpp/style/conversion/url_or_tileset.cpp

@@ -0,0 +1,30 @@
+#include "url_or_tileset.hpp"
+#include "../android_conversion.hpp"
+
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/tileset.hpp>
+
+namespace mbgl {
+namespace android {
+
+// This conversion is expected not to fail because it's used only in contexts where
+// the value was originally a String or TileSet object on the Java side. If it fails
+// to convert, it's a bug in our serialization or Java-side static typing.
+variant<std::string, Tileset> convertURLOrTileset(mbgl::android::Value&& value) {
+    using namespace mbgl::style::conversion;
+
+    const Convertible convertible(std::move(value));
+    if (isObject(convertible)) {
+        Error error;
+        optional<Tileset> tileset = convert<Tileset>(convertible, error);
+        if (!tileset) {
+            throw std::logic_error(error.message);
+        }
+        return { *tileset };
+    } else {
+        return { *toString(convertible) };
+    }
+}
+
+}
+}

MapboxGLAndroidSDK/src/cpp/style/conversion/url_or_tileset.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <mbgl/util/variant.hpp>
+#include <mbgl/util/tileset.hpp>
+
+#include <string>
+
+#include "../value.hpp"
+
+namespace mbgl {
+namespace android {
+
+variant<std::string, Tileset> convertURLOrTileset(mbgl::android::Value&& value);
+
+}
+}

MapboxGLAndroidSDK/src/cpp/style/formatted.cpp

@@ -0,0 +1,54 @@
+#include "formatted.hpp"
+#include "formatted_section.hpp"
+#include "../conversion/conversion.hpp"
+#include "../conversion/constant.hpp"
+
+namespace mbgl {
+namespace android {
+
+void Formatted::registerNative(jni::JNIEnv& env) {
+    jni::Class<Formatted>::Singleton(env);
+}
+
+jni::Local<jni::Object<Formatted>> Formatted::New(jni::JNIEnv& env, const style::expression::Formatted& value) {
+    static auto& formatted = jni::Class<Formatted>::Singleton(env);
+    static auto formattedConstructor = formatted.GetConstructor<jni::Array<jni::Object<FormattedSection>>>(env);
+    static auto& formattedSectionClass = jni::Class<FormattedSection>::Singleton(env);
+
+    auto sections = jni::Array<jni::Object<FormattedSection>>::New(env, value.sections.size());
+    for (std::size_t i = 0; i < value.sections.size(); i++) {
+        auto section = value.sections.at(i);
+        auto text = jni::Make<jni::String>(env, section.text);
+        static auto formattedSectionConstructor = formattedSectionClass.GetConstructor<jni::String>(env);
+        auto formattedSection = formattedSectionClass.New(env, formattedSectionConstructor, text);
+
+        if (section.fontScale) {
+            double fontScale = section.fontScale.value();
+            static auto method = formattedSectionClass.GetMethod<void (jni::Number)>(env, "setFontScale");
+            formattedSection.Call(env, method, jni::Box(env, fontScale));
+        }
+
+        if (section.fontStack) {
+            auto fontStack = jni::Array<jni::String>::New(env, section.fontStack.value().size());
+            for (std::size_t j = 0; j < section.fontStack.value().size(); j++) {
+                fontStack.Set(env, j, jni::Make<jni::String>(env, section.fontStack.value().at(j)));
+            }
+            static auto method = formattedSectionClass.GetMethod<void (jni::Array<jni::String>)>(env, "setFontStack");
+            formattedSection.Call(env, method, fontStack);
+        }
+
+        if (section.textColor) {
+            using namespace mbgl::android::conversion;
+            auto textColor = std::move(*convert<jni::Local<jni::Object<>>>(env, *section.textColor));
+            static auto method = formattedSectionClass.GetMethod<void (jni::Object<>)>(env, "setTextColor");
+            formattedSection.Call(env, method, textColor);
+        }
+
+        sections.Set(env, i, formattedSection);
+    }
+
+    return formatted.New(env, formattedConstructor, sections);
+}
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/formatted.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+
+#include <jni/jni.hpp>
+#include <mbgl/style/expression/formatted.hpp>
+
+namespace mbgl {
+    namespace android {
+
+        using SuperTag = jni::ObjectTag;
+        class Formatted : private mbgl::util::noncopyable {
+        public:
+            static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/types/Formatted"; };
+
+            static jni::Local<jni::Object<Formatted>>
+            New(jni::JNIEnv&, const style::expression::Formatted &value);
+
+            static void registerNative(jni::JNIEnv &);
+        };
+
+    } // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/formatted_section.cpp

@@ -0,0 +1,11 @@
+#include "formatted_section.hpp"
+
+namespace mbgl {
+namespace android {
+
+void FormattedSection::registerNative(jni::JNIEnv& env) {
+    jni::Class<FormattedSection>::Singleton(env);
+}
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/formatted_section.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class FormattedSection : private mbgl::util::noncopyable {
+public:
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/types/FormattedSection"; };
+
+    static void registerNative(jni::JNIEnv&);
+};
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/background_layer.cpp

@@ -0,0 +1,148 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include "background_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+#include "../conversion/transition_options.hpp"
+
+#include <mbgl/style/layer_impl.hpp>
+
+namespace mbgl {
+namespace android {
+
+    inline mbgl::style::BackgroundLayer& toBackgroundLayer(mbgl::style::Layer& layer) {
+        return static_cast<mbgl::style::BackgroundLayer&>(layer);
+    }
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map) from the JVM side
+     */
+    BackgroundLayer::BackgroundLayer(jni::JNIEnv& env, jni::String& layerId)
+        : Layer(std::make_unique<mbgl::style::BackgroundLayer>(jni::Make<std::string>(env, layerId))) {
+    }
+
+    /**
+     * Creates a non-owning peer object (for layers currently attached to the map)
+     */
+    BackgroundLayer::BackgroundLayer(mbgl::style::BackgroundLayer& coreLayer) : Layer(coreLayer) {}
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map)
+     */
+    BackgroundLayer::BackgroundLayer(std::unique_ptr<mbgl::style::BackgroundLayer> coreLayer)
+        : Layer(std::move(coreLayer)) {}
+
+    BackgroundLayer::~BackgroundLayer() = default;
+
+    // Property getters
+
+    jni::Local<jni::Object<>> BackgroundLayer::getBackgroundColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toBackgroundLayer(layer).getBackgroundColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> BackgroundLayer::getBackgroundColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toBackgroundLayer(layer).getBackgroundColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void BackgroundLayer::setBackgroundColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toBackgroundLayer(layer).setBackgroundColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> BackgroundLayer::getBackgroundPattern(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toBackgroundLayer(layer).getBackgroundPattern()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> BackgroundLayer::getBackgroundPatternTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toBackgroundLayer(layer).getBackgroundPatternTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void BackgroundLayer::setBackgroundPatternTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toBackgroundLayer(layer).setBackgroundPatternTransition(options);
+    }
+
+    jni::Local<jni::Object<>> BackgroundLayer::getBackgroundOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toBackgroundLayer(layer).getBackgroundOpacity()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> BackgroundLayer::getBackgroundOpacityTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toBackgroundLayer(layer).getBackgroundOpacityTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void BackgroundLayer::setBackgroundOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toBackgroundLayer(layer).setBackgroundOpacityTransition(options);
+    }
+
+
+    // BackgroundJavaLayerPeerFactory
+
+    BackgroundJavaLayerPeerFactory::~BackgroundJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<BackgroundLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> BackgroundJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                                       mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env, new BackgroundLayer(toBackgroundLayer(layer)));
+    }
+
+    jni::Local<jni::Object<Layer>> BackgroundJavaLayerPeerFactory::createJavaLayerPeer(
+        jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env,
+                              new BackgroundLayer(std::unique_ptr<mbgl::style::BackgroundLayer>(
+                                  static_cast<mbgl::style::BackgroundLayer*>(layer.release()))));
+    }
+
+    void BackgroundJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<BackgroundLayer>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<BackgroundLayer>(
+            env,
+            javaClass,
+            "nativePtr",
+            jni::MakePeer<BackgroundLayer, jni::String&>,
+            "initialize",
+            "finalize",
+            METHOD(&BackgroundLayer::getBackgroundColorTransition, "nativeGetBackgroundColorTransition"),
+            METHOD(&BackgroundLayer::setBackgroundColorTransition, "nativeSetBackgroundColorTransition"),
+            METHOD(&BackgroundLayer::getBackgroundColor, "nativeGetBackgroundColor"),
+            METHOD(&BackgroundLayer::getBackgroundPatternTransition, "nativeGetBackgroundPatternTransition"),
+            METHOD(&BackgroundLayer::setBackgroundPatternTransition, "nativeSetBackgroundPatternTransition"),
+            METHOD(&BackgroundLayer::getBackgroundPattern, "nativeGetBackgroundPattern"),
+            METHOD(&BackgroundLayer::getBackgroundOpacityTransition, "nativeGetBackgroundOpacityTransition"),
+            METHOD(&BackgroundLayer::setBackgroundOpacityTransition, "nativeSetBackgroundOpacityTransition"),
+            METHOD(&BackgroundLayer::getBackgroundOpacity, "nativeGetBackgroundOpacity"));
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/background_layer.hpp

@@ -0,0 +1,58 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include "layer.hpp"
+#include "../transition_options.hpp"
+#include <mbgl/layermanager/background_layer_factory.hpp>
+#include <mbgl/style/layers/background_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class BackgroundLayer : public Layer {
+public:
+    using SuperTag = Layer;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/BackgroundLayer"; };
+
+    BackgroundLayer(jni::JNIEnv&, jni::String&);
+
+    BackgroundLayer(mbgl::style::BackgroundLayer&);
+
+    BackgroundLayer(std::unique_ptr<mbgl::style::BackgroundLayer>);
+
+    ~BackgroundLayer();
+
+    // Properties
+
+    jni::Local<jni::Object<jni::ObjectTag>> getBackgroundColor(jni::JNIEnv&);
+    void setBackgroundColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getBackgroundColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getBackgroundPattern(jni::JNIEnv&);
+    void setBackgroundPatternTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getBackgroundPatternTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getBackgroundOpacity(jni::JNIEnv&);
+    void setBackgroundOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getBackgroundOpacityTransition(jni::JNIEnv&);
+
+}; // class BackgroundLayer
+
+class BackgroundJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::BackgroundLayerFactory {
+public:
+    ~BackgroundJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    LayerFactory* getLayerFactory() final { return this; }
+
+};  // class BackgroundJavaLayerPeerFactory
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/circle_layer.cpp

@@ -0,0 +1,270 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include "circle_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+#include "../conversion/transition_options.hpp"
+
+#include <mbgl/style/layer_impl.hpp>
+
+namespace mbgl {
+namespace android {
+
+    inline mbgl::style::CircleLayer& toCircleLayer(mbgl::style::Layer& layer) {
+        return static_cast<mbgl::style::CircleLayer&>(layer);
+    }
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map) from the JVM side
+     */
+    CircleLayer::CircleLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
+        : Layer(std::make_unique<mbgl::style::CircleLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+    }
+
+    /**
+     * Creates a non-owning peer object (for layers currently attached to the map)
+     */
+    CircleLayer::CircleLayer(mbgl::style::CircleLayer& coreLayer) : Layer(coreLayer) {}
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map)
+     */
+    CircleLayer::CircleLayer(std::unique_ptr<mbgl::style::CircleLayer> coreLayer) : Layer(std::move(coreLayer)) {}
+
+    CircleLayer::~CircleLayer() = default;
+
+    // Property getters
+
+    jni::Local<jni::Object<>> CircleLayer::getCircleRadius(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleRadius()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleRadiusTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleRadiusTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void CircleLayer::setCircleRadiusTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toCircleLayer(layer).setCircleRadiusTransition(options);
+    }
+
+    jni::Local<jni::Object<>> CircleLayer::getCircleColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void CircleLayer::setCircleColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toCircleLayer(layer).setCircleColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> CircleLayer::getCircleBlur(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleBlur()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleBlurTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleBlurTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void CircleLayer::setCircleBlurTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toCircleLayer(layer).setCircleBlurTransition(options);
+    }
+
+    jni::Local<jni::Object<>> CircleLayer::getCircleOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleOpacity()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleOpacityTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleOpacityTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void CircleLayer::setCircleOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toCircleLayer(layer).setCircleOpacityTransition(options);
+    }
+
+    jni::Local<jni::Object<>> CircleLayer::getCircleTranslate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleTranslate()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleTranslateTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleTranslateTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void CircleLayer::setCircleTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toCircleLayer(layer).setCircleTranslateTransition(options);
+    }
+
+    jni::Local<jni::Object<>> CircleLayer::getCircleTranslateAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleTranslateAnchor()));
+    }
+
+    jni::Local<jni::Object<>> CircleLayer::getCirclePitchScale(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCirclePitchScale()));
+    }
+
+    jni::Local<jni::Object<>> CircleLayer::getCirclePitchAlignment(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCirclePitchAlignment()));
+    }
+
+    jni::Local<jni::Object<>> CircleLayer::getCircleStrokeWidth(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleStrokeWidth()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleStrokeWidthTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleStrokeWidthTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void CircleLayer::setCircleStrokeWidthTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toCircleLayer(layer).setCircleStrokeWidthTransition(options);
+    }
+
+    jni::Local<jni::Object<>> CircleLayer::getCircleStrokeColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleStrokeColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleStrokeColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleStrokeColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void CircleLayer::setCircleStrokeColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toCircleLayer(layer).setCircleStrokeColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> CircleLayer::getCircleStrokeOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleStrokeOpacity()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleStrokeOpacityTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleStrokeOpacityTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void CircleLayer::setCircleStrokeOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toCircleLayer(layer).setCircleStrokeOpacityTransition(options);
+    }
+
+
+    // CircleJavaLayerPeerFactory
+
+    CircleJavaLayerPeerFactory::~CircleJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<CircleLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> CircleJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                                   mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env, new CircleLayer(toCircleLayer(layer)));
+    }
+
+    jni::Local<jni::Object<Layer>> CircleJavaLayerPeerFactory::createJavaLayerPeer(
+        jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env,
+                              new CircleLayer(std::unique_ptr<mbgl::style::CircleLayer>(
+                                  static_cast<mbgl::style::CircleLayer*>(layer.release()))));
+    }
+
+    void CircleJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<CircleLayer>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<CircleLayer>(
+            env,
+            javaClass,
+            "nativePtr",
+            jni::MakePeer<CircleLayer, jni::String&, jni::String&>,
+            "initialize",
+            "finalize",
+            METHOD(&CircleLayer::getCircleRadiusTransition, "nativeGetCircleRadiusTransition"),
+            METHOD(&CircleLayer::setCircleRadiusTransition, "nativeSetCircleRadiusTransition"),
+            METHOD(&CircleLayer::getCircleRadius, "nativeGetCircleRadius"),
+            METHOD(&CircleLayer::getCircleColorTransition, "nativeGetCircleColorTransition"),
+            METHOD(&CircleLayer::setCircleColorTransition, "nativeSetCircleColorTransition"),
+            METHOD(&CircleLayer::getCircleColor, "nativeGetCircleColor"),
+            METHOD(&CircleLayer::getCircleBlurTransition, "nativeGetCircleBlurTransition"),
+            METHOD(&CircleLayer::setCircleBlurTransition, "nativeSetCircleBlurTransition"),
+            METHOD(&CircleLayer::getCircleBlur, "nativeGetCircleBlur"),
+            METHOD(&CircleLayer::getCircleOpacityTransition, "nativeGetCircleOpacityTransition"),
+            METHOD(&CircleLayer::setCircleOpacityTransition, "nativeSetCircleOpacityTransition"),
+            METHOD(&CircleLayer::getCircleOpacity, "nativeGetCircleOpacity"),
+            METHOD(&CircleLayer::getCircleTranslateTransition, "nativeGetCircleTranslateTransition"),
+            METHOD(&CircleLayer::setCircleTranslateTransition, "nativeSetCircleTranslateTransition"),
+            METHOD(&CircleLayer::getCircleTranslate, "nativeGetCircleTranslate"),
+            METHOD(&CircleLayer::getCircleTranslateAnchor, "nativeGetCircleTranslateAnchor"),
+            METHOD(&CircleLayer::getCirclePitchScale, "nativeGetCirclePitchScale"),
+            METHOD(&CircleLayer::getCirclePitchAlignment, "nativeGetCirclePitchAlignment"),
+            METHOD(&CircleLayer::getCircleStrokeWidthTransition, "nativeGetCircleStrokeWidthTransition"),
+            METHOD(&CircleLayer::setCircleStrokeWidthTransition, "nativeSetCircleStrokeWidthTransition"),
+            METHOD(&CircleLayer::getCircleStrokeWidth, "nativeGetCircleStrokeWidth"),
+            METHOD(&CircleLayer::getCircleStrokeColorTransition, "nativeGetCircleStrokeColorTransition"),
+            METHOD(&CircleLayer::setCircleStrokeColorTransition, "nativeSetCircleStrokeColorTransition"),
+            METHOD(&CircleLayer::getCircleStrokeColor, "nativeGetCircleStrokeColor"),
+            METHOD(&CircleLayer::getCircleStrokeOpacityTransition, "nativeGetCircleStrokeOpacityTransition"),
+            METHOD(&CircleLayer::setCircleStrokeOpacityTransition, "nativeSetCircleStrokeOpacityTransition"),
+            METHOD(&CircleLayer::getCircleStrokeOpacity, "nativeGetCircleStrokeOpacity"));
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/circle_layer.hpp

@@ -0,0 +1,84 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include "layer.hpp"
+#include "../transition_options.hpp"
+#include <mbgl/layermanager/circle_layer_factory.hpp>
+#include <mbgl/style/layers/circle_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class CircleLayer : public Layer {
+public:
+    using SuperTag = Layer;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/CircleLayer"; };
+
+    CircleLayer(jni::JNIEnv&, jni::String&, jni::String&);
+
+    CircleLayer(mbgl::style::CircleLayer&);
+
+    CircleLayer(std::unique_ptr<mbgl::style::CircleLayer>);
+
+    ~CircleLayer();
+
+    // Properties
+
+    jni::Local<jni::Object<jni::ObjectTag>> getCircleRadius(jni::JNIEnv&);
+    void setCircleRadiusTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getCircleRadiusTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getCircleColor(jni::JNIEnv&);
+    void setCircleColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getCircleColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getCircleBlur(jni::JNIEnv&);
+    void setCircleBlurTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getCircleBlurTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getCircleOpacity(jni::JNIEnv&);
+    void setCircleOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getCircleOpacityTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getCircleTranslate(jni::JNIEnv&);
+    void setCircleTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getCircleTranslateTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getCircleTranslateAnchor(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getCirclePitchScale(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getCirclePitchAlignment(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getCircleStrokeWidth(jni::JNIEnv&);
+    void setCircleStrokeWidthTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getCircleStrokeWidthTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getCircleStrokeColor(jni::JNIEnv&);
+    void setCircleStrokeColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getCircleStrokeColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getCircleStrokeOpacity(jni::JNIEnv&);
+    void setCircleStrokeOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getCircleStrokeOpacityTransition(jni::JNIEnv&);
+
+}; // class CircleLayer
+
+class CircleJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::CircleLayerFactory {
+public:
+    ~CircleJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    LayerFactory* getLayerFactory() final { return this; }
+
+};  // class CircleJavaLayerPeerFactory
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/custom_layer.cpp

@@ -0,0 +1,61 @@
+#include "custom_layer.hpp"
+
+#include <string>
+
+#include <mbgl/util/logging.hpp>
+
+namespace mbgl {
+namespace android {
+
+    CustomLayer::CustomLayer(jni::JNIEnv& env, const jni::String& layerId, jni::jlong host)
+        : Layer(std::make_unique<mbgl::style::CustomLayer>(
+                jni::Make<std::string>(env, layerId),
+                std::unique_ptr<mbgl::style::CustomLayerHost>(reinterpret_cast<mbgl::style::CustomLayerHost*>(host)))
+                ) {
+    }
+
+    CustomLayer::CustomLayer(mbgl::style::CustomLayer& coreLayer) : Layer(coreLayer) {}
+
+    CustomLayer::CustomLayer(std::unique_ptr<mbgl::style::CustomLayer> coreLayer) : Layer(std::move(coreLayer)) {}
+
+    CustomLayer::~CustomLayer() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<CustomLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }
+
+    CustomJavaLayerPeerFactory::~CustomJavaLayerPeerFactory() = default;
+
+    jni::Local<jni::Object<Layer>> CustomJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                                   mbgl::style::Layer& layer) {
+        return createJavaPeer(env, new CustomLayer(static_cast<mbgl::style::CustomLayer&>(layer)));
+    }
+
+    jni::Local<jni::Object<Layer>> CustomJavaLayerPeerFactory::createJavaLayerPeer(
+        jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+        return createJavaPeer(env,
+                              new CustomLayer(std::unique_ptr<mbgl::style::CustomLayer>(
+                                  static_cast<mbgl::style::CustomLayer*>(layer.release()))));
+    }
+
+    void CustomJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<CustomLayer>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<CustomLayer>(env,
+                                             javaClass,
+                                             "nativePtr",
+                                             jni::MakePeer<CustomLayer, const jni::String&, jni::jlong>,
+                                             "initialize",
+                                             "finalize");
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/custom_layer.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <jni/jni.hpp>
+#include <mbgl/gl/custom_layer.hpp>
+#include <mbgl/gl/custom_layer_factory.hpp>
+#include "layer.hpp"
+
+namespace mbgl {
+namespace android {
+
+class CustomLayer : public Layer {
+public:
+    using SuperTag = Layer;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/CustomLayer"; };
+
+    static void registerNative(jni::JNIEnv&);
+
+    CustomLayer(jni::JNIEnv&, const jni::String&, jni::jlong);
+    CustomLayer(mbgl::style::CustomLayer&);
+    CustomLayer(std::unique_ptr<mbgl::style::CustomLayer>);
+    ~CustomLayer();
+
+    jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
+}; // class CustomLayer
+
+class CustomJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::CustomLayerFactory {
+public:
+    ~CustomJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    LayerFactory* getLayerFactory() final { return this; }
+
+};  // class CustomJavaLayerPeerFactory
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/fill_extrusion_layer.cpp

@@ -0,0 +1,225 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include "fill_extrusion_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+#include "../conversion/transition_options.hpp"
+
+#include <mbgl/style/layer_impl.hpp>
+
+namespace mbgl {
+namespace android {
+
+    inline mbgl::style::FillExtrusionLayer& toFillExtrusionLayer(mbgl::style::Layer& layer) {
+        return static_cast<mbgl::style::FillExtrusionLayer&>(layer);
+    }
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map) from the JVM side
+     */
+    FillExtrusionLayer::FillExtrusionLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
+        : Layer(std::make_unique<mbgl::style::FillExtrusionLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+    }
+
+    /**
+     * Creates a non-owning peer object (for layers currently attached to the map)
+     */
+    FillExtrusionLayer::FillExtrusionLayer(mbgl::style::FillExtrusionLayer& coreLayer) : Layer(coreLayer) {}
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map)
+     */
+    FillExtrusionLayer::FillExtrusionLayer(std::unique_ptr<mbgl::style::FillExtrusionLayer> coreLayer)
+        : Layer(std::move(coreLayer)) {}
+
+    FillExtrusionLayer::~FillExtrusionLayer() = default;
+
+    // Property getters
+
+    jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionOpacity()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionOpacityTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionOpacityTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void FillExtrusionLayer::setFillExtrusionOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toFillExtrusionLayer(layer).setFillExtrusionOpacityTransition(options);
+    }
+
+    jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void FillExtrusionLayer::setFillExtrusionColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toFillExtrusionLayer(layer).setFillExtrusionColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionTranslate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionTranslate()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionTranslateTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionTranslateTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void FillExtrusionLayer::setFillExtrusionTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toFillExtrusionLayer(layer).setFillExtrusionTranslateTransition(options);
+    }
+
+    jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionTranslateAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionTranslateAnchor()));
+    }
+
+    jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionPattern(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionPattern()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionPatternTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionPatternTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void FillExtrusionLayer::setFillExtrusionPatternTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toFillExtrusionLayer(layer).setFillExtrusionPatternTransition(options);
+    }
+
+    jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionHeight(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionHeight()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionHeightTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionHeightTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void FillExtrusionLayer::setFillExtrusionHeightTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toFillExtrusionLayer(layer).setFillExtrusionHeightTransition(options);
+    }
+
+    jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionBase(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionBase()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionBaseTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionBaseTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void FillExtrusionLayer::setFillExtrusionBaseTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toFillExtrusionLayer(layer).setFillExtrusionBaseTransition(options);
+    }
+
+    jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionVerticalGradient(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionVerticalGradient()));
+    }
+
+
+    // FillExtrusionJavaLayerPeerFactory
+
+    FillExtrusionJavaLayerPeerFactory::~FillExtrusionJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<FillExtrusionLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> FillExtrusionJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                                          mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env, new FillExtrusionLayer(toFillExtrusionLayer(layer)));
+    }
+
+    jni::Local<jni::Object<Layer>> FillExtrusionJavaLayerPeerFactory::createJavaLayerPeer(
+        jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env,
+                              new FillExtrusionLayer(std::unique_ptr<mbgl::style::FillExtrusionLayer>(
+                                  static_cast<mbgl::style::FillExtrusionLayer*>(layer.release()))));
+    }
+
+    void FillExtrusionJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<FillExtrusionLayer>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<FillExtrusionLayer>(
+            env,
+            javaClass,
+            "nativePtr",
+            jni::MakePeer<FillExtrusionLayer, jni::String&, jni::String&>,
+            "initialize",
+            "finalize",
+            METHOD(&FillExtrusionLayer::getFillExtrusionOpacityTransition, "nativeGetFillExtrusionOpacityTransition"),
+            METHOD(&FillExtrusionLayer::setFillExtrusionOpacityTransition, "nativeSetFillExtrusionOpacityTransition"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionOpacity, "nativeGetFillExtrusionOpacity"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionColorTransition, "nativeGetFillExtrusionColorTransition"),
+            METHOD(&FillExtrusionLayer::setFillExtrusionColorTransition, "nativeSetFillExtrusionColorTransition"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionColor, "nativeGetFillExtrusionColor"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionTranslateTransition,
+                   "nativeGetFillExtrusionTranslateTransition"),
+            METHOD(&FillExtrusionLayer::setFillExtrusionTranslateTransition,
+                   "nativeSetFillExtrusionTranslateTransition"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionTranslate, "nativeGetFillExtrusionTranslate"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionTranslateAnchor, "nativeGetFillExtrusionTranslateAnchor"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionPatternTransition, "nativeGetFillExtrusionPatternTransition"),
+            METHOD(&FillExtrusionLayer::setFillExtrusionPatternTransition, "nativeSetFillExtrusionPatternTransition"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionPattern, "nativeGetFillExtrusionPattern"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionHeightTransition, "nativeGetFillExtrusionHeightTransition"),
+            METHOD(&FillExtrusionLayer::setFillExtrusionHeightTransition, "nativeSetFillExtrusionHeightTransition"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionHeight, "nativeGetFillExtrusionHeight"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionBaseTransition, "nativeGetFillExtrusionBaseTransition"),
+            METHOD(&FillExtrusionLayer::setFillExtrusionBaseTransition, "nativeSetFillExtrusionBaseTransition"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionBase, "nativeGetFillExtrusionBase"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionVerticalGradient, "nativeGetFillExtrusionVerticalGradient"));
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/fill_extrusion_layer.hpp

@@ -0,0 +1,74 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include "layer.hpp"
+#include "../transition_options.hpp"
+#include <mbgl/layermanager/fill_extrusion_layer_factory.hpp>
+#include <mbgl/style/layers/fill_extrusion_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class FillExtrusionLayer : public Layer {
+public:
+    using SuperTag = Layer;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/FillExtrusionLayer"; };
+
+    FillExtrusionLayer(jni::JNIEnv&, jni::String&, jni::String&);
+
+    FillExtrusionLayer(mbgl::style::FillExtrusionLayer&);
+
+    FillExtrusionLayer(std::unique_ptr<mbgl::style::FillExtrusionLayer>);
+
+    ~FillExtrusionLayer();
+
+    // Properties
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillExtrusionOpacity(jni::JNIEnv&);
+    void setFillExtrusionOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getFillExtrusionOpacityTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillExtrusionColor(jni::JNIEnv&);
+    void setFillExtrusionColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getFillExtrusionColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillExtrusionTranslate(jni::JNIEnv&);
+    void setFillExtrusionTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getFillExtrusionTranslateTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillExtrusionTranslateAnchor(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillExtrusionPattern(jni::JNIEnv&);
+    void setFillExtrusionPatternTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getFillExtrusionPatternTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillExtrusionHeight(jni::JNIEnv&);
+    void setFillExtrusionHeightTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getFillExtrusionHeightTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillExtrusionBase(jni::JNIEnv&);
+    void setFillExtrusionBaseTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getFillExtrusionBaseTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillExtrusionVerticalGradient(jni::JNIEnv&);
+
+}; // class FillExtrusionLayer
+
+class FillExtrusionJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::FillExtrusionLayerFactory {
+public:
+    ~FillExtrusionJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    LayerFactory* getLayerFactory() final { return this; }
+
+};  // class FillExtrusionJavaLayerPeerFactory
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/fill_layer.cpp

@@ -0,0 +1,207 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include "fill_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+#include "../conversion/transition_options.hpp"
+
+#include <mbgl/style/layer_impl.hpp>
+
+namespace mbgl {
+namespace android {
+
+    inline mbgl::style::FillLayer& toFillLayer(mbgl::style::Layer& layer) {
+        return static_cast<mbgl::style::FillLayer&>(layer);
+    }
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map) from the JVM side
+     */
+    FillLayer::FillLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
+        : Layer(std::make_unique<mbgl::style::FillLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+    }
+
+    /**
+     * Creates a non-owning peer object (for layers currently attached to the map)
+     */
+    FillLayer::FillLayer(mbgl::style::FillLayer& coreLayer) : Layer(coreLayer) {}
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map)
+     */
+    FillLayer::FillLayer(std::unique_ptr<mbgl::style::FillLayer> coreLayer) : Layer(std::move(coreLayer)) {}
+
+    FillLayer::~FillLayer() = default;
+
+    // Property getters
+
+    jni::Local<jni::Object<>> FillLayer::getFillSortKey(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillLayer(layer).getFillSortKey()));
+    }
+
+    jni::Local<jni::Object<>> FillLayer::getFillAntialias(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillLayer(layer).getFillAntialias()));
+    }
+
+    jni::Local<jni::Object<>> FillLayer::getFillOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillLayer(layer).getFillOpacity()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> FillLayer::getFillOpacityTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toFillLayer(layer).getFillOpacityTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void FillLayer::setFillOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toFillLayer(layer).setFillOpacityTransition(options);
+    }
+
+    jni::Local<jni::Object<>> FillLayer::getFillColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillLayer(layer).getFillColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> FillLayer::getFillColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toFillLayer(layer).getFillColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void FillLayer::setFillColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toFillLayer(layer).setFillColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> FillLayer::getFillOutlineColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillLayer(layer).getFillOutlineColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> FillLayer::getFillOutlineColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toFillLayer(layer).getFillOutlineColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void FillLayer::setFillOutlineColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toFillLayer(layer).setFillOutlineColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> FillLayer::getFillTranslate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillLayer(layer).getFillTranslate()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> FillLayer::getFillTranslateTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toFillLayer(layer).getFillTranslateTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void FillLayer::setFillTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toFillLayer(layer).setFillTranslateTransition(options);
+    }
+
+    jni::Local<jni::Object<>> FillLayer::getFillTranslateAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillLayer(layer).getFillTranslateAnchor()));
+    }
+
+    jni::Local<jni::Object<>> FillLayer::getFillPattern(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillLayer(layer).getFillPattern()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> FillLayer::getFillPatternTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toFillLayer(layer).getFillPatternTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void FillLayer::setFillPatternTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toFillLayer(layer).setFillPatternTransition(options);
+    }
+
+
+    // FillJavaLayerPeerFactory
+
+    FillJavaLayerPeerFactory::~FillJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<FillLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> FillJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                                 mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env, new FillLayer(toFillLayer(layer)));
+    }
+
+    jni::Local<jni::Object<Layer>> FillJavaLayerPeerFactory::createJavaLayerPeer(
+        jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env,
+                              new FillLayer(std::unique_ptr<mbgl::style::FillLayer>(
+                                  static_cast<mbgl::style::FillLayer*>(layer.release()))));
+    }
+
+    void FillJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<FillLayer>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<FillLayer>(
+            env,
+            javaClass,
+            "nativePtr",
+            jni::MakePeer<FillLayer, jni::String&, jni::String&>,
+            "initialize",
+            "finalize",
+            METHOD(&FillLayer::getFillSortKey, "nativeGetFillSortKey"),
+            METHOD(&FillLayer::getFillAntialias, "nativeGetFillAntialias"),
+            METHOD(&FillLayer::getFillOpacityTransition, "nativeGetFillOpacityTransition"),
+            METHOD(&FillLayer::setFillOpacityTransition, "nativeSetFillOpacityTransition"),
+            METHOD(&FillLayer::getFillOpacity, "nativeGetFillOpacity"),
+            METHOD(&FillLayer::getFillColorTransition, "nativeGetFillColorTransition"),
+            METHOD(&FillLayer::setFillColorTransition, "nativeSetFillColorTransition"),
+            METHOD(&FillLayer::getFillColor, "nativeGetFillColor"),
+            METHOD(&FillLayer::getFillOutlineColorTransition, "nativeGetFillOutlineColorTransition"),
+            METHOD(&FillLayer::setFillOutlineColorTransition, "nativeSetFillOutlineColorTransition"),
+            METHOD(&FillLayer::getFillOutlineColor, "nativeGetFillOutlineColor"),
+            METHOD(&FillLayer::getFillTranslateTransition, "nativeGetFillTranslateTransition"),
+            METHOD(&FillLayer::setFillTranslateTransition, "nativeSetFillTranslateTransition"),
+            METHOD(&FillLayer::getFillTranslate, "nativeGetFillTranslate"),
+            METHOD(&FillLayer::getFillTranslateAnchor, "nativeGetFillTranslateAnchor"),
+            METHOD(&FillLayer::getFillPatternTransition, "nativeGetFillPatternTransition"),
+            METHOD(&FillLayer::setFillPatternTransition, "nativeSetFillPatternTransition"),
+            METHOD(&FillLayer::getFillPattern, "nativeGetFillPattern"));
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/fill_layer.hpp

@@ -0,0 +1,72 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include "layer.hpp"
+#include "../transition_options.hpp"
+#include <mbgl/layermanager/fill_layer_factory.hpp>
+#include <mbgl/style/layers/fill_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class FillLayer : public Layer {
+public:
+    using SuperTag = Layer;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/FillLayer"; };
+
+    FillLayer(jni::JNIEnv&, jni::String&, jni::String&);
+
+    FillLayer(mbgl::style::FillLayer&);
+
+    FillLayer(std::unique_ptr<mbgl::style::FillLayer>);
+
+    ~FillLayer();
+
+    // Properties
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillSortKey(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillAntialias(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillOpacity(jni::JNIEnv&);
+    void setFillOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getFillOpacityTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillColor(jni::JNIEnv&);
+    void setFillColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getFillColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillOutlineColor(jni::JNIEnv&);
+    void setFillOutlineColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getFillOutlineColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillTranslate(jni::JNIEnv&);
+    void setFillTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getFillTranslateTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillTranslateAnchor(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getFillPattern(jni::JNIEnv&);
+    void setFillPatternTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getFillPatternTransition(jni::JNIEnv&);
+
+}; // class FillLayer
+
+class FillJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::FillLayerFactory {
+public:
+    ~FillJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    LayerFactory* getLayerFactory() final { return this; }
+
+};  // class FillJavaLayerPeerFactory
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/heatmap_layer.cpp

@@ -0,0 +1,163 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include "heatmap_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+#include "../conversion/transition_options.hpp"
+
+#include <mbgl/style/layer_impl.hpp>
+
+namespace mbgl {
+namespace android {
+
+    inline mbgl::style::HeatmapLayer& toHeatmapLayer(mbgl::style::Layer& layer) {
+        return static_cast<mbgl::style::HeatmapLayer&>(layer);
+    }
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map) from the JVM side
+     */
+    HeatmapLayer::HeatmapLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
+        : Layer(std::make_unique<mbgl::style::HeatmapLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+    }
+
+    /**
+     * Creates a non-owning peer object (for layers currently attached to the map)
+     */
+    HeatmapLayer::HeatmapLayer(mbgl::style::HeatmapLayer& coreLayer) : Layer(coreLayer) {}
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map)
+     */
+    HeatmapLayer::HeatmapLayer(std::unique_ptr<mbgl::style::HeatmapLayer> coreLayer) : Layer(std::move(coreLayer)) {}
+
+    HeatmapLayer::~HeatmapLayer() = default;
+
+    // Property getters
+
+    jni::Local<jni::Object<>> HeatmapLayer::getHeatmapRadius(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toHeatmapLayer(layer).getHeatmapRadius()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> HeatmapLayer::getHeatmapRadiusTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toHeatmapLayer(layer).getHeatmapRadiusTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void HeatmapLayer::setHeatmapRadiusTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toHeatmapLayer(layer).setHeatmapRadiusTransition(options);
+    }
+
+    jni::Local<jni::Object<>> HeatmapLayer::getHeatmapWeight(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toHeatmapLayer(layer).getHeatmapWeight()));
+    }
+
+    jni::Local<jni::Object<>> HeatmapLayer::getHeatmapIntensity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toHeatmapLayer(layer).getHeatmapIntensity()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> HeatmapLayer::getHeatmapIntensityTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toHeatmapLayer(layer).getHeatmapIntensityTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void HeatmapLayer::setHeatmapIntensityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toHeatmapLayer(layer).setHeatmapIntensityTransition(options);
+    }
+
+    jni::Local<jni::Object<>> HeatmapLayer::getHeatmapColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        auto propertyValue =  toHeatmapLayer(layer).getHeatmapColor();
+        if (propertyValue.isUndefined()) {
+            propertyValue =  toHeatmapLayer(layer).getDefaultHeatmapColor();
+        }
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, propertyValue));
+    }
+
+    jni::Local<jni::Object<>> HeatmapLayer::getHeatmapOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toHeatmapLayer(layer).getHeatmapOpacity()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> HeatmapLayer::getHeatmapOpacityTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toHeatmapLayer(layer).getHeatmapOpacityTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void HeatmapLayer::setHeatmapOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toHeatmapLayer(layer).setHeatmapOpacityTransition(options);
+    }
+
+
+    // HeatmapJavaLayerPeerFactory
+
+    HeatmapJavaLayerPeerFactory::~HeatmapJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<HeatmapLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> HeatmapJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                                    mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env, new HeatmapLayer(toHeatmapLayer(layer)));
+    }
+
+    jni::Local<jni::Object<Layer>> HeatmapJavaLayerPeerFactory::createJavaLayerPeer(
+        jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env,
+                              new HeatmapLayer(std::unique_ptr<mbgl::style::HeatmapLayer>(
+                                  static_cast<mbgl::style::HeatmapLayer*>(layer.release()))));
+    }
+
+    void HeatmapJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<HeatmapLayer>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<HeatmapLayer>(
+            env,
+            javaClass,
+            "nativePtr",
+            jni::MakePeer<HeatmapLayer, jni::String&, jni::String&>,
+            "initialize",
+            "finalize",
+            METHOD(&HeatmapLayer::getHeatmapRadiusTransition, "nativeGetHeatmapRadiusTransition"),
+            METHOD(&HeatmapLayer::setHeatmapRadiusTransition, "nativeSetHeatmapRadiusTransition"),
+            METHOD(&HeatmapLayer::getHeatmapRadius, "nativeGetHeatmapRadius"),
+            METHOD(&HeatmapLayer::getHeatmapWeight, "nativeGetHeatmapWeight"),
+            METHOD(&HeatmapLayer::getHeatmapIntensityTransition, "nativeGetHeatmapIntensityTransition"),
+            METHOD(&HeatmapLayer::setHeatmapIntensityTransition, "nativeSetHeatmapIntensityTransition"),
+            METHOD(&HeatmapLayer::getHeatmapIntensity, "nativeGetHeatmapIntensity"),
+            METHOD(&HeatmapLayer::getHeatmapColor, "nativeGetHeatmapColor"),
+            METHOD(&HeatmapLayer::getHeatmapOpacityTransition, "nativeGetHeatmapOpacityTransition"),
+            METHOD(&HeatmapLayer::setHeatmapOpacityTransition, "nativeSetHeatmapOpacityTransition"),
+            METHOD(&HeatmapLayer::getHeatmapOpacity, "nativeGetHeatmapOpacity"));
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/heatmap_layer.hpp

@@ -0,0 +1,62 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include "layer.hpp"
+#include "../transition_options.hpp"
+#include <mbgl/layermanager/heatmap_layer_factory.hpp>
+#include <mbgl/style/layers/heatmap_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class HeatmapLayer : public Layer {
+public:
+    using SuperTag = Layer;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/HeatmapLayer"; };
+
+    HeatmapLayer(jni::JNIEnv&, jni::String&, jni::String&);
+
+    HeatmapLayer(mbgl::style::HeatmapLayer&);
+
+    HeatmapLayer(std::unique_ptr<mbgl::style::HeatmapLayer>);
+
+    ~HeatmapLayer();
+
+    // Properties
+
+    jni::Local<jni::Object<jni::ObjectTag>> getHeatmapRadius(jni::JNIEnv&);
+    void setHeatmapRadiusTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getHeatmapRadiusTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getHeatmapWeight(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getHeatmapIntensity(jni::JNIEnv&);
+    void setHeatmapIntensityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getHeatmapIntensityTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getHeatmapColor(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getHeatmapOpacity(jni::JNIEnv&);
+    void setHeatmapOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getHeatmapOpacityTransition(jni::JNIEnv&);
+
+}; // class HeatmapLayer
+
+class HeatmapJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::HeatmapLayerFactory {
+public:
+    ~HeatmapJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    LayerFactory* getLayerFactory() final { return this; }
+
+};  // class HeatmapJavaLayerPeerFactory
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/hillshade_layer.cpp

@@ -0,0 +1,181 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include "hillshade_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+#include "../conversion/transition_options.hpp"
+
+#include <mbgl/style/layer_impl.hpp>
+
+namespace mbgl {
+namespace android {
+
+    inline mbgl::style::HillshadeLayer& toHillshadeLayer(mbgl::style::Layer& layer) {
+        return static_cast<mbgl::style::HillshadeLayer&>(layer);
+    }
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map) from the JVM side
+     */
+    HillshadeLayer::HillshadeLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
+        : Layer(std::make_unique<mbgl::style::HillshadeLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+    }
+
+    /**
+     * Creates a non-owning peer object (for layers currently attached to the map)
+     */
+    HillshadeLayer::HillshadeLayer(mbgl::style::HillshadeLayer& coreLayer) : Layer(coreLayer) {}
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map)
+     */
+    HillshadeLayer::HillshadeLayer(std::unique_ptr<mbgl::style::HillshadeLayer> coreLayer)
+        : Layer(std::move(coreLayer)) {}
+
+    HillshadeLayer::~HillshadeLayer() = default;
+
+    // Property getters
+
+    jni::Local<jni::Object<>> HillshadeLayer::getHillshadeIlluminationDirection(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toHillshadeLayer(layer).getHillshadeIlluminationDirection()));
+    }
+
+    jni::Local<jni::Object<>> HillshadeLayer::getHillshadeIlluminationAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toHillshadeLayer(layer).getHillshadeIlluminationAnchor()));
+    }
+
+    jni::Local<jni::Object<>> HillshadeLayer::getHillshadeExaggeration(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toHillshadeLayer(layer).getHillshadeExaggeration()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> HillshadeLayer::getHillshadeExaggerationTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toHillshadeLayer(layer).getHillshadeExaggerationTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void HillshadeLayer::setHillshadeExaggerationTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toHillshadeLayer(layer).setHillshadeExaggerationTransition(options);
+    }
+
+    jni::Local<jni::Object<>> HillshadeLayer::getHillshadeShadowColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toHillshadeLayer(layer).getHillshadeShadowColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> HillshadeLayer::getHillshadeShadowColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toHillshadeLayer(layer).getHillshadeShadowColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void HillshadeLayer::setHillshadeShadowColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toHillshadeLayer(layer).setHillshadeShadowColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> HillshadeLayer::getHillshadeHighlightColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toHillshadeLayer(layer).getHillshadeHighlightColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> HillshadeLayer::getHillshadeHighlightColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toHillshadeLayer(layer).getHillshadeHighlightColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void HillshadeLayer::setHillshadeHighlightColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toHillshadeLayer(layer).setHillshadeHighlightColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> HillshadeLayer::getHillshadeAccentColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toHillshadeLayer(layer).getHillshadeAccentColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> HillshadeLayer::getHillshadeAccentColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toHillshadeLayer(layer).getHillshadeAccentColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void HillshadeLayer::setHillshadeAccentColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toHillshadeLayer(layer).setHillshadeAccentColorTransition(options);
+    }
+
+
+    // HillshadeJavaLayerPeerFactory
+
+    HillshadeJavaLayerPeerFactory::~HillshadeJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<HillshadeLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> HillshadeJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                                      mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env, new HillshadeLayer(toHillshadeLayer(layer)));
+    }
+
+    jni::Local<jni::Object<Layer>> HillshadeJavaLayerPeerFactory::createJavaLayerPeer(
+        jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env,
+                              new HillshadeLayer(std::unique_ptr<mbgl::style::HillshadeLayer>(
+                                  static_cast<mbgl::style::HillshadeLayer*>(layer.release()))));
+    }
+
+    void HillshadeJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<HillshadeLayer>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<HillshadeLayer>(
+            env,
+            javaClass,
+            "nativePtr",
+            jni::MakePeer<HillshadeLayer, jni::String&, jni::String&>,
+            "initialize",
+            "finalize",
+            METHOD(&HillshadeLayer::getHillshadeIlluminationDirection, "nativeGetHillshadeIlluminationDirection"),
+            METHOD(&HillshadeLayer::getHillshadeIlluminationAnchor, "nativeGetHillshadeIlluminationAnchor"),
+            METHOD(&HillshadeLayer::getHillshadeExaggerationTransition, "nativeGetHillshadeExaggerationTransition"),
+            METHOD(&HillshadeLayer::setHillshadeExaggerationTransition, "nativeSetHillshadeExaggerationTransition"),
+            METHOD(&HillshadeLayer::getHillshadeExaggeration, "nativeGetHillshadeExaggeration"),
+            METHOD(&HillshadeLayer::getHillshadeShadowColorTransition, "nativeGetHillshadeShadowColorTransition"),
+            METHOD(&HillshadeLayer::setHillshadeShadowColorTransition, "nativeSetHillshadeShadowColorTransition"),
+            METHOD(&HillshadeLayer::getHillshadeShadowColor, "nativeGetHillshadeShadowColor"),
+            METHOD(&HillshadeLayer::getHillshadeHighlightColorTransition, "nativeGetHillshadeHighlightColorTransition"),
+            METHOD(&HillshadeLayer::setHillshadeHighlightColorTransition, "nativeSetHillshadeHighlightColorTransition"),
+            METHOD(&HillshadeLayer::getHillshadeHighlightColor, "nativeGetHillshadeHighlightColor"),
+            METHOD(&HillshadeLayer::getHillshadeAccentColorTransition, "nativeGetHillshadeAccentColorTransition"),
+            METHOD(&HillshadeLayer::setHillshadeAccentColorTransition, "nativeSetHillshadeAccentColorTransition"),
+            METHOD(&HillshadeLayer::getHillshadeAccentColor, "nativeGetHillshadeAccentColor"));
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/hillshade_layer.hpp

@@ -0,0 +1,66 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include "layer.hpp"
+#include "../transition_options.hpp"
+#include <mbgl/layermanager/hillshade_layer_factory.hpp>
+#include <mbgl/style/layers/hillshade_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class HillshadeLayer : public Layer {
+public:
+    using SuperTag = Layer;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/HillshadeLayer"; };
+
+    HillshadeLayer(jni::JNIEnv&, jni::String&, jni::String&);
+
+    HillshadeLayer(mbgl::style::HillshadeLayer&);
+
+    HillshadeLayer(std::unique_ptr<mbgl::style::HillshadeLayer>);
+
+    ~HillshadeLayer();
+
+    // Properties
+
+    jni::Local<jni::Object<jni::ObjectTag>> getHillshadeIlluminationDirection(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getHillshadeIlluminationAnchor(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getHillshadeExaggeration(jni::JNIEnv&);
+    void setHillshadeExaggerationTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getHillshadeExaggerationTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getHillshadeShadowColor(jni::JNIEnv&);
+    void setHillshadeShadowColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getHillshadeShadowColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getHillshadeHighlightColor(jni::JNIEnv&);
+    void setHillshadeHighlightColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getHillshadeHighlightColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getHillshadeAccentColor(jni::JNIEnv&);
+    void setHillshadeAccentColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getHillshadeAccentColorTransition(jni::JNIEnv&);
+
+}; // class HillshadeLayer
+
+class HillshadeJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::HillshadeLayerFactory {
+public:
+    ~HillshadeJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    LayerFactory* getLayerFactory() final { return this; }
+
+};  // class HillshadeJavaLayerPeerFactory
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/layer.cpp

@@ -0,0 +1,178 @@
+#include "layer.hpp"
+#include "../android_conversion.hpp"
+
+#include <jni/jni.hpp>
+
+#include <mbgl/style/style.hpp>
+#include <mbgl/style/filter.hpp>
+#include <mbgl/style/transition_options.hpp>
+#include <mbgl/style/layers/background_layer.hpp>
+#include <mbgl/style/layers/circle_layer.hpp>
+#include <mbgl/style/layers/fill_layer.hpp>
+#include <mbgl/style/layers/fill_extrusion_layer.hpp>
+#include <mbgl/style/layers/heatmap_layer.hpp>
+#include <mbgl/style/layers/hillshade_layer.hpp>
+#include <mbgl/style/layers/line_layer.hpp>
+#include <mbgl/style/layers/raster_layer.hpp>
+#include <mbgl/style/layers/symbol_layer.hpp>
+#include <mbgl/util/logging.hpp>
+
+// Java -> C++ conversion
+#include <mbgl/style/conversion/filter.hpp>
+#include <mbgl/style/conversion/layer.hpp>
+#include <mbgl/style/conversion/source.hpp>
+#include <mbgl/style/conversion_impl.hpp>
+
+// C++ -> Java conversion
+#include "../conversion/property_value.hpp"
+#include "custom_layer.hpp"
+#include "background_layer.hpp"
+#include <mbgl/style/filter.hpp>
+
+#include <string>
+
+namespace mbgl {
+namespace android {
+
+    /**
+     * Invoked when the construction is initiated from the jvm through a subclass
+     */
+    Layer::Layer(std::unique_ptr<mbgl::style::Layer> coreLayer)
+        : ownedLayer(std::move(coreLayer))
+        , layer(*ownedLayer) {
+    }
+
+    /**
+     * Takes a non-owning reference. For lookup methods
+     */
+    Layer::Layer(mbgl::style::Layer& coreLayer) : layer(coreLayer) {}
+
+    Layer::~Layer() {
+    }
+
+    void Layer::addToStyle(mbgl::style::Style& style, mbgl::optional<std::string> before) {
+        // Check to see if we own the layer first
+        if (!ownedLayer) {
+            throw std::runtime_error("Cannot add layer twice");
+        }
+
+        // Add layer to map
+        style.addLayer(releaseCoreLayer(), before);
+    }
+
+    void Layer::setLayer(std::unique_ptr<mbgl::style::Layer> sourceLayer) {
+        this->ownedLayer = std::move(sourceLayer);
+    }
+
+    std::unique_ptr<mbgl::style::Layer> Layer::releaseCoreLayer() {
+        assert(ownedLayer != nullptr);
+        return std::move(ownedLayer);
+    }
+
+    jni::Local<jni::String> Layer::getId(jni::JNIEnv& env) {
+        return jni::Make<jni::String>(env, layer.getID());
+    }
+
+    style::Layer& Layer::get() {
+        return layer;
+    }
+
+    void Layer::setProperty(jni::JNIEnv& env, const jni::String& jname, const jni::Object<>& jvalue) {
+        // Convert and set property
+        optional<mbgl::style::conversion::Error> error =
+            layer.setProperty(jni::Make<std::string>(env, jname), Value(env, jvalue));
+        if (error) {
+            mbgl::Log::Error(mbgl::Event::JNI, "Error setting property: " + jni::Make<std::string>(env, jname) + " " + error->message);
+            return;
+        }
+    }
+
+    void Layer::setFilter(jni::JNIEnv& env, const jni::Array<jni::Object<>>& jfilter) {
+        using namespace mbgl::style;
+        using namespace mbgl::style::conversion;
+
+        Error error;
+        optional<Filter> converted = convert<Filter>(Value(env, jfilter), error);
+        if (!converted) {
+            mbgl::Log::Error(mbgl::Event::JNI, "Error setting filter: " + error.message);
+            return;
+        }
+
+        layer.setFilter(std::move(*converted));
+    }
+
+    jni::Local<jni::Object<gson::JsonElement>> Layer::getFilter(jni::JNIEnv& env) {
+        using namespace mbgl::style;
+        using namespace mbgl::style::conversion;
+
+        Filter filter = layer.getFilter();
+        if (filter.expression) {
+            mbgl::Value expressionValue = (*filter.expression)->serialize();
+            return gson::JsonElement::New(env, expressionValue);
+        } else {
+            return jni::Local<jni::Object<gson::JsonElement>>(env, nullptr);
+        }
+    }
+
+    void Layer::setSourceLayer(jni::JNIEnv& env, const jni::String& sourceLayer) {
+        layer.setSourceLayer(jni::Make<std::string>(env, sourceLayer));
+    }
+
+    jni::Local<jni::String> Layer::getSourceLayer(jni::JNIEnv& env) {
+        return jni::Make<jni::String>(env, layer.getSourceLayer());
+    }
+
+    jni::Local<jni::String> Layer::getSourceId(jni::JNIEnv& env) {
+        return jni::Make<jni::String>(env, layer.getSourceID());
+    }
+
+    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::Local<jni::Object<>> Layer::getVisibility(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, layer.getVisibility()));
+    }
+
+    void Layer::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<Layer>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<Layer>(
+            env,
+            javaClass,
+            "nativePtr",
+            METHOD(&Layer::getId, "nativeGetId"),
+            METHOD(&Layer::setProperty,
+                   "nativeSetLayoutProperty"), // TODO : Export only nativeSetProperty() when #15970 lands.
+            METHOD(&Layer::setProperty, "nativeSetPaintProperty"),
+            METHOD(&Layer::setFilter, "nativeSetFilter"),
+            METHOD(&Layer::getFilter, "nativeGetFilter"),
+            METHOD(&Layer::setSourceLayer, "nativeSetSourceLayer"),
+            METHOD(&Layer::getSourceLayer, "nativeGetSourceLayer"),
+            METHOD(&Layer::getSourceId, "nativeGetSourceId"),
+            METHOD(&Layer::getMinZoom, "nativeGetMinZoom"),
+            METHOD(&Layer::getMaxZoom, "nativeGetMaxZoom"),
+            METHOD(&Layer::setMinZoom, "nativeSetMinZoom"),
+            METHOD(&Layer::setMaxZoom, "nativeSetMaxZoom"),
+            METHOD(&Layer::getVisibility, "nativeGetVisibility"));
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/layer.cpp.ejs

@@ -0,0 +1,139 @@
+<%
+  const type = locals.type;
+  const properties = locals.properties;
+-%>
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include "<%- type.replace('-', '_') %>_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+#include "../conversion/transition_options.hpp"
+
+#include <mbgl/style/layer_impl.hpp>
+
+namespace mbgl {
+namespace android {
+
+    inline mbgl::style::<%- camelize(type) %>Layer& to<%- camelize(type) %>Layer(mbgl::style::Layer& layer) {
+        return static_cast<mbgl::style::<%- camelize(type) %>Layer&>(layer);
+    }
+
+<% if (type === 'background') { -%>
+    /**
+     * Creates an owning peer object (for layers not attached to the map) from the JVM side
+     */
+    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(jni::JNIEnv& env, jni::String& layerId)
+        : Layer(std::make_unique<mbgl::style::<%- camelize(type) %>Layer>(jni::Make<std::string>(env, layerId))) {
+<% } else { -%>
+    /**
+     * Creates an owning peer object (for layers not attached to the map) from the JVM side
+     */
+    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
+        : Layer(std::make_unique<mbgl::style::<%- camelize(type) %>Layer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+<% } -%>
+    }
+
+    /**
+     * Creates a non-owning peer object (for layers currently attached to the map)
+     */
+    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(mbgl::style::<%- camelize(type) %>Layer& coreLayer)
+        : Layer(coreLayer) {
+    }
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map)
+     */
+    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer> coreLayer)
+        : Layer(std::move(coreLayer)) {
+    }
+
+    <%- camelize(type) %>Layer::~<%- camelize(type) %>Layer() = default;
+
+    // Property getters
+
+<% for (const property of properties) { -%>
+<% if (property.name != 'heatmap-color') { -%>
+    jni::Local<jni::Object<>> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, to<%- camelize(type) %>Layer(layer).get<%- camelize(property.name) %>()));
+    }
+
+<% } else { -%>
+    jni::Local<jni::Object<>> HeatmapLayer::getHeatmapColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        auto propertyValue =  to<%- camelize(type) %>Layer(layer).getHeatmapColor();
+        if (propertyValue.isUndefined()) {
+            propertyValue =  to<%- camelize(type) %>Layer(layer).getDefaultHeatmapColor();
+        }
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, propertyValue));
+    }
+
+<% } -%>
+<% if (property.transition) { -%>
+    jni::Local<jni::Object<TransitionOptions>> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>Transition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = to<%- camelize(type) %>Layer(layer).get<%- camelize(property.name) %>Transition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>Transition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        to<%- camelize(type) %>Layer(layer).set<%- camelize(property.name) %>Transition(options);
+    }
+
+<% } -%>
+<% } -%>
+
+    // <%- camelize(type) %>JavaLayerPeerFactory
+
+    <%- camelize(type) %>JavaLayerPeerFactory::~<%- camelize(type) %>JavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<<%- camelize(type) %>Layer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> <%- camelize(type) %>JavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env, new <%- camelize(type) %>Layer(to<%- camelize(type) %>Layer(layer)));
+    }
+
+    jni::Local<jni::Object<Layer>> <%- camelize(type) %>JavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env, new <%- camelize(type) %>Layer(std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer>(static_cast<mbgl::style::<%- camelize(type) %>Layer*>(layer.release()))));
+    }
+
+    void <%- camelize(type) %>JavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<<%- camelize(type) %>Layer>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<<%- camelize(type) %>Layer>(
+            env,
+            javaClass,
+            "nativePtr",
+<% if (type === 'background') { -%>
+            jni::MakePeer<<%- camelize(type) %>Layer, jni::String&>,
+<% } else { -%>
+            jni::MakePeer<<%- camelize(type) %>Layer, jni::String&, jni::String&>,
+<% } -%>
+            "initialize",
+            "finalize",<% for(var i = 0; i < properties.length; i++) {%>
+<% if (properties[i].transition) { -%>
+            METHOD(&<%- camelize(type) %>Layer::get<%- camelize(properties[i].name) %>Transition, "nativeGet<%- camelize(properties[i].name) %>Transition"),
+            METHOD(&<%- camelize(type) %>Layer::set<%- camelize(properties[i].name) %>Transition, "nativeSet<%- camelize(properties[i].name) %>Transition"),
+<% } -%>
+            METHOD(&<%- camelize(type) %>Layer::get<%- camelize(properties[i].name) %>, "nativeGet<%- camelize(properties[i].name) %>")<% if(i != (properties.length -1)) {-%>,<% } -%><% } -%>);
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/layer.hpp

@@ -0,0 +1,117 @@
+#pragma once
+
+#include <mbgl/layermanager/layer_factory.hpp>
+#include <mbgl/style/layer.hpp>
+#include <mbgl/style/style.hpp>
+#include "../../gson/json_array.hpp"
+#include "../../gson/json_element.hpp"
+#include "../value.hpp"
+
+#include <jni/jni.hpp>
+
+namespace mbgl {
+
+namespace android {
+
+class Layer {
+public:
+
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/Layer"; };
+
+    static void registerNative(jni::JNIEnv&);
+
+    virtual ~Layer();
+
+    /**
+     * Set core layer (ie return ownership after remove)
+     */
+    void setLayer(std::unique_ptr<mbgl::style::Layer>);
+
+    void addToStyle(mbgl::style::Style&, mbgl::optional<std::string>);
+
+    // Release the owned view and return it
+    std::unique_ptr<mbgl::style::Layer> releaseCoreLayer();
+
+    jni::Local<jni::String> getId(jni::JNIEnv&);
+
+    jni::Local<jni::String> getSourceId(jni::JNIEnv&);
+
+    style::Layer& get();
+
+    void setProperty(jni::JNIEnv&, const jni::String&, const jni::Object<>& value);
+
+    // 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&, const jni::Array<jni::Object<>>&);
+
+    jni::Local<jni::Object<gson::JsonElement>> getFilter(jni::JNIEnv&);
+
+    void setSourceLayer(jni::JNIEnv&, const jni::String&);
+
+    jni::Local<jni::String> getSourceLayer(jni::JNIEnv&);
+
+    // Property getters
+
+    jni::Local<jni::Object<jni::ObjectTag>> getVisibility(jni::JNIEnv&);
+
+protected:
+    /*
+     * Called when a non-owning peer object is created on the c++ side
+     */
+    Layer(mbgl::style::Layer&);
+
+    /*
+     * Called when a owning peer object is created on the c++ side
+     */
+    Layer(std::unique_ptr<mbgl::style::Layer>);
+
+    // Owned layer is set when creating a new layer, before adding it to the map
+    std::unique_ptr<mbgl::style::Layer> ownedLayer;
+
+    // Raw reference to the layer
+    mbgl::style::Layer& layer;
+};
+
+/**
+ * @brief A factory class for a layer Java peer objects of a certain type.
+ */
+class JavaLayerPeerFactory {
+public:
+    virtual ~JavaLayerPeerFactory() = default;
+    /**
+     * @brief Create a non-owning peer.
+     */
+    virtual jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) = 0;
+
+    /**
+     * @brief Create an owning peer.
+     */
+    virtual jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env,
+                                                               std::unique_ptr<mbgl::style::Layer>) = 0;
+
+    /**
+     * @brief Register peer methods.
+     */
+    virtual void registerNative(jni::JNIEnv&) = 0;
+
+    /**
+     * @brief Get the corresponding layer factory.
+     * 
+     * @return style::LayerFactory* must not be \c nullptr.
+     */
+    virtual LayerFactory* getLayerFactory() = 0;
+};
+
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/layer.hpp.ejs

@@ -0,0 +1,62 @@
+<%
+  const type = locals.type;
+  const properties = locals.properties;
+-%>
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include "layer.hpp"
+#include "../transition_options.hpp"
+#include <mbgl/layermanager/<%- type.replace('-', '_') %>_layer_factory.hpp>
+#include <mbgl/style/layers/<%- type.replace('-', '_') %>_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class <%- camelize(type) %>Layer : public Layer {
+public:
+    using SuperTag = Layer;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/<%- camelize(type) %>Layer"; };
+
+<% if (type === 'background') { -%>
+    <%- camelize(type) %>Layer(jni::JNIEnv&, jni::String&);
+<% } else { -%>
+    <%- camelize(type) %>Layer(jni::JNIEnv&, jni::String&, jni::String&);
+<% } -%>
+
+    <%- camelize(type) %>Layer(mbgl::style::<%- camelize(type) %>Layer&);
+
+    <%- camelize(type) %>Layer(std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer>);
+
+    ~<%- camelize(type) %>Layer();
+
+    // Properties
+<% for (const property of properties) { -%>
+
+    jni::Local<jni::Object<jni::ObjectTag>> get<%- camelize(property.name) %>(jni::JNIEnv&);
+<% if (property.transition) { -%>
+    void set<%- camelize(property.name) %>Transition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> get<%- camelize(property.name) %>Transition(jni::JNIEnv&);
+<% } -%>
+<% } -%>
+
+}; // class <%- camelize(type) %>Layer
+
+class <%- camelize(type) %>JavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::<%- camelize(type) %>LayerFactory {
+public:
+    ~<%- camelize(type) %>JavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    LayerFactory* getLayerFactory() final { return this; }
+
+};  // class <%- camelize(type) %>JavaLayerPeerFactory
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/layer_manager.cpp

@@ -0,0 +1,173 @@
+#include "layer_manager.hpp"
+
+#include <mbgl/style/layer_impl.hpp>
+
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/filter.hpp>
+#include <mbgl/style/conversion_impl.hpp>
+
+#include "background_layer.hpp"
+#include "circle_layer.hpp"
+#include "custom_layer.hpp"
+#include "fill_extrusion_layer.hpp"
+#include "fill_layer.hpp"
+#include "heatmap_layer.hpp"
+#include "hillshade_layer.hpp"
+#include "line_layer.hpp"
+#include "raster_layer.hpp"
+#include "symbol_layer.hpp"
+#include "fill_extrusion_layer.hpp"
+
+namespace mbgl {
+
+namespace android {
+
+LayerManagerAndroid::LayerManagerAndroid() {
+#if defined(MBGL_LAYER_FILL_DISABLE_RUNTIME)
+    addLayerTypeCoreOnly(std::make_unique<FillLayerFactory>());
+#elif !defined(MBGL_LAYER_FILL_DISABLE_ALL)
+    addLayerType(std::make_unique<FillJavaLayerPeerFactory>());
+#endif
+#if defined(MBGL_LAYER_LINE_DISABLE_RUNTIME)
+    addLayerTypeCoreOnly(std::make_unique<LineLayerFactory>());
+#elif !defined(MBGL_LAYER_LINE_DISABLE_ALL)
+    addLayerType(std::make_unique<LineJavaLayerPeerFactory>());
+#endif
+#if defined(MBGL_LAYER_CIRCLE_DISABLE_RUNTIME)
+    addLayerTypeCoreOnly(std::make_unique<CircleLayerFactory>());
+#elif !defined(MBGL_LAYER_CIRCLE_DISABLE_ALL)
+    addLayerType(std::make_unique<CircleJavaLayerPeerFactory>());
+#endif
+#if defined(MBGL_LAYER_SYMBOL_DISABLE_RUNTIME)
+    addLayerTypeCoreOnly(std::make_unique<SymbolLayerFactory>());
+#elif !defined(MBGL_LAYER_SYMBOL_DISABLE_ALL)
+    addLayerType(std::make_unique<SymbolJavaLayerPeerFactory>());
+#endif
+#if defined(MBGL_LAYER_RASTER_DISABLE_RUNTIME)
+    addLayerTypeCoreOnly(std::make_unique<RasterLayerFactory>());
+#elif !defined(MBGL_LAYER_RASTER_DISABLE_ALL)
+    addLayerType(std::make_unique<RasterJavaLayerPeerFactory>());
+#endif
+#if defined(MBGL_LAYER_BACKGROUND_DISABLE_RUNTIME)
+    addLayerTypeCoreOnly(std::make_unique<BackgroundLayerFactory>());
+#elif !defined(MBGL_LAYER_BACKGROUND_DISABLE_ALL)
+    addLayerType(std::make_unique<BackgroundJavaLayerPeerFactory>());
+#endif
+#if defined(MBGL_LAYER_HILLSHADE_DISABLE_RUNTIME)
+    addLayerTypeCoreOnly(std::make_unique<HillshadeLayerFactory>());
+#elif !defined(MBGL_LAYER_HILLSHADE_DISABLE_ALL)
+    addLayerType(std::make_unique<HillshadeJavaLayerPeerFactory>());
+#endif
+#if defined(MBGL_LAYER_FILL_EXTRUSION_DISABLE_RUNTIME)
+    addLayerTypeCoreOnly(std::make_unique<FillExtrusionLayerFactory>());
+#elif !defined(MBGL_LAYER_FILL_EXTRUSION_DISABLE_ALL)
+    addLayerType(std::make_unique<FillExtrusionJavaLayerPeerFactory>());
+#endif
+#if defined(MBGL_LAYER_HEATMAP_DISABLE_RUNTIME)
+    addLayerTypeCoreOnly(std::make_unique<HeatmapLayerFactory>());
+#elif !defined(MBGL_LAYER_HEATMAP_DISABLE_ALL)
+    addLayerType(std::make_unique<HeatmapJavaLayerPeerFactory>());
+#endif
+#if defined(MBGL_LAYER_CUSTOM_DISABLE_RUNTIME)
+    addLayerTypeCoreOnly(std::make_unique<CustomLayerFactory>());
+#elif !defined(MBGL_LAYER_CUSTOM_DISABLE_ALL)
+    addLayerType(std::make_unique<CustomJavaLayerPeerFactory>());
+#endif
+}
+
+LayerManagerAndroid::~LayerManagerAndroid() = default;
+
+jni::Local<jni::Object<Layer>> LayerManagerAndroid::createJavaLayerPeer(jni::JNIEnv& env, mbgl::style::Layer& layer) {
+    if (JavaLayerPeerFactory* factory = getPeerFactory(layer.getTypeInfo())) {
+        return factory->createJavaLayerPeer(env, layer);
+    }
+    return jni::Local<jni::Object<Layer>>();
+}
+
+jni::Local<jni::Object<Layer>> LayerManagerAndroid::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                        std::unique_ptr<mbgl::style::Layer> layer) {
+    if (JavaLayerPeerFactory* factory = getPeerFactory(layer->getTypeInfo())) {
+        return factory->createJavaLayerPeer(env, std::move(layer));
+    }
+    return jni::Local<jni::Object<Layer>>();
+}
+
+void LayerManagerAndroid::registerNative(jni::JNIEnv& env) {
+    if (peerFactories.empty()) {
+        return;
+    }
+
+    Layer::registerNative(env);
+    for (const auto& factory: peerFactories) {
+        factory->registerNative(env);
+    }
+}
+
+void LayerManagerAndroid::addLayerType(std::unique_ptr<JavaLayerPeerFactory> factory) {
+    assert(getFactory(factory->getLayerFactory()->getTypeInfo()) == nullptr);
+    registerCoreFactory(factory->getLayerFactory());
+    peerFactories.emplace_back(std::move(factory));
+}
+
+void LayerManagerAndroid::addLayerTypeCoreOnly(std::unique_ptr<LayerFactory> factory) {
+    assert(getFactory(factory->getTypeInfo()) == nullptr);
+    registerCoreFactory(factory.get());
+    coreFactories.emplace_back(std::move(factory));
+}
+
+void LayerManagerAndroid::registerCoreFactory(mbgl::LayerFactory* factory) {
+    std::string type{factory->getTypeInfo()->type};
+    if (!type.empty()) {
+        assert(typeToFactory.find(type) == typeToFactory.end());
+        typeToFactory.emplace(std::make_pair(std::move(type), factory));
+    }
+}
+
+JavaLayerPeerFactory* LayerManagerAndroid::getPeerFactory(const mbgl::style::LayerTypeInfo* typeInfo) {
+    assert(typeInfo);
+    for (const auto& factory: peerFactories) {
+        if (factory->getLayerFactory()->getTypeInfo() == typeInfo) {
+            return factory.get();
+        }
+    }
+    return nullptr;
+}
+
+LayerFactory* LayerManagerAndroid::getFactory(const std::string& type) noexcept {
+    auto search = typeToFactory.find(type);
+    return (search != typeToFactory.end()) ? search->second : nullptr;
+}
+
+LayerFactory* LayerManagerAndroid::getFactory(const mbgl::style::LayerTypeInfo* info) noexcept {
+    if (JavaLayerPeerFactory* peerFactory = getPeerFactory(info)) {
+        return peerFactory->getLayerFactory();
+    }
+
+    for (const auto& factory: coreFactories) {
+        if (factory->getTypeInfo() == info) {
+            return factory.get();
+        }
+    }
+
+    return nullptr;
+}
+
+// static
+LayerManagerAndroid* LayerManagerAndroid::get() noexcept {
+    static LayerManagerAndroid impl;
+    return &impl;
+}
+
+} // namespace android
+
+LayerManager* LayerManager::get() noexcept {
+    return android::LayerManagerAndroid::get();
+}
+
+#if defined(MBGL_LAYER_LINE_DISABLE_ALL) || defined(MBGL_LAYER_SYMBOL_DISABLE_ALL) || defined(MBGL_LAYER_FILL_DISABLE_ALL)
+const bool LayerManager::annotationsEnabled = false;
+#else
+const bool LayerManager::annotationsEnabled = true;
+#endif
+
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/layer_manager.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <mbgl/layermanager/layer_manager.hpp>
+#include <mbgl/map/map.hpp>
+#include <mbgl/style/layer.hpp>
+
+#include "layer.hpp"
+
+#include <jni/jni.hpp>
+
+#include <memory>
+#include <vector>
+
+namespace mbgl {
+namespace android {
+
+/**
+ * @brief A singleton class forwarding calls to the corresponding  \c JavaLayerPeerFactory instance.
+ */
+class LayerManagerAndroid final : public mbgl::LayerManager {
+public:
+    ~LayerManagerAndroid() final;
+    static LayerManagerAndroid* get() noexcept;
+
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&);
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>);
+
+    void registerNative(jni::JNIEnv&);
+
+private:
+    LayerManagerAndroid();
+    /**
+     * @brief Enables a layer type for both JSON style and runtime API.
+     */
+    void addLayerType(std::unique_ptr<JavaLayerPeerFactory>); 
+    /**
+     * @brief Enables a layer type for JSON style only.
+     *
+     * We might not want to expose runtime API for some layer types
+     * in order to save binary size - JNI glue code for these layer types
+     * won't be added to the binary. 
+     */
+    void addLayerTypeCoreOnly(std::unique_ptr<mbgl::LayerFactory>);
+
+    void registerCoreFactory(mbgl::LayerFactory*);
+    JavaLayerPeerFactory* getPeerFactory(const mbgl::style::LayerTypeInfo*);
+    // mbgl::LayerManager overrides.
+    LayerFactory* getFactory(const std::string& type) noexcept final;
+    LayerFactory* getFactory(const mbgl::style::LayerTypeInfo* info) noexcept final;
+
+    std::vector<std::unique_ptr<JavaLayerPeerFactory>> peerFactories;
+    std::vector<std::unique_ptr<mbgl::LayerFactory>> coreFactories;
+    std::map<std::string, mbgl::LayerFactory*> typeToFactory;
+};
+
+}  // namespace android
+}  // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/line_layer.cpp

@@ -0,0 +1,315 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include "line_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+#include "../conversion/transition_options.hpp"
+
+#include <mbgl/style/layer_impl.hpp>
+
+namespace mbgl {
+namespace android {
+
+    inline mbgl::style::LineLayer& toLineLayer(mbgl::style::Layer& layer) {
+        return static_cast<mbgl::style::LineLayer&>(layer);
+    }
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map) from the JVM side
+     */
+    LineLayer::LineLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
+        : Layer(std::make_unique<mbgl::style::LineLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+    }
+
+    /**
+     * Creates a non-owning peer object (for layers currently attached to the map)
+     */
+    LineLayer::LineLayer(mbgl::style::LineLayer& coreLayer) : Layer(coreLayer) {}
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map)
+     */
+    LineLayer::LineLayer(std::unique_ptr<mbgl::style::LineLayer> coreLayer) : Layer(std::move(coreLayer)) {}
+
+    LineLayer::~LineLayer() = default;
+
+    // Property getters
+
+    jni::Local<jni::Object<>> LineLayer::getLineCap(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineCap()));
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineJoin(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineJoin()));
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineMiterLimit(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineMiterLimit()));
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineRoundLimit(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineRoundLimit()));
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineSortKey(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineSortKey()));
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineOpacity()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> LineLayer::getLineOpacityTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toLineLayer(layer).getLineOpacityTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void LineLayer::setLineOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toLineLayer(layer).setLineOpacityTransition(options);
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> LineLayer::getLineColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toLineLayer(layer).getLineColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void LineLayer::setLineColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toLineLayer(layer).setLineColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineTranslate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineTranslate()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> LineLayer::getLineTranslateTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toLineLayer(layer).getLineTranslateTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void LineLayer::setLineTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toLineLayer(layer).setLineTranslateTransition(options);
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineTranslateAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineTranslateAnchor()));
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineWidth(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineWidth()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> LineLayer::getLineWidthTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toLineLayer(layer).getLineWidthTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void LineLayer::setLineWidthTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toLineLayer(layer).setLineWidthTransition(options);
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineGapWidth(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineGapWidth()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> LineLayer::getLineGapWidthTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toLineLayer(layer).getLineGapWidthTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void LineLayer::setLineGapWidthTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toLineLayer(layer).setLineGapWidthTransition(options);
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineOffset(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineOffset()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> LineLayer::getLineOffsetTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toLineLayer(layer).getLineOffsetTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void LineLayer::setLineOffsetTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toLineLayer(layer).setLineOffsetTransition(options);
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineBlur(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineBlur()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> LineLayer::getLineBlurTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toLineLayer(layer).getLineBlurTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void LineLayer::setLineBlurTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toLineLayer(layer).setLineBlurTransition(options);
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineDasharray(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineDasharray()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> LineLayer::getLineDasharrayTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toLineLayer(layer).getLineDasharrayTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void LineLayer::setLineDasharrayTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toLineLayer(layer).setLineDasharrayTransition(options);
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLinePattern(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLinePattern()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> LineLayer::getLinePatternTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toLineLayer(layer).getLinePatternTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void LineLayer::setLinePatternTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toLineLayer(layer).setLinePatternTransition(options);
+    }
+
+    jni::Local<jni::Object<>> LineLayer::getLineGradient(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLineLayer(layer).getLineGradient()));
+    }
+
+
+    // LineJavaLayerPeerFactory
+
+    LineJavaLayerPeerFactory::~LineJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<LineLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> LineJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                                 mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env, new LineLayer(toLineLayer(layer)));
+    }
+
+    jni::Local<jni::Object<Layer>> LineJavaLayerPeerFactory::createJavaLayerPeer(
+        jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env,
+                              new LineLayer(std::unique_ptr<mbgl::style::LineLayer>(
+                                  static_cast<mbgl::style::LineLayer*>(layer.release()))));
+    }
+
+    void LineJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<LineLayer>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<LineLayer>(
+            env,
+            javaClass,
+            "nativePtr",
+            jni::MakePeer<LineLayer, jni::String&, jni::String&>,
+            "initialize",
+            "finalize",
+            METHOD(&LineLayer::getLineCap, "nativeGetLineCap"),
+            METHOD(&LineLayer::getLineJoin, "nativeGetLineJoin"),
+            METHOD(&LineLayer::getLineMiterLimit, "nativeGetLineMiterLimit"),
+            METHOD(&LineLayer::getLineRoundLimit, "nativeGetLineRoundLimit"),
+            METHOD(&LineLayer::getLineSortKey, "nativeGetLineSortKey"),
+            METHOD(&LineLayer::getLineOpacityTransition, "nativeGetLineOpacityTransition"),
+            METHOD(&LineLayer::setLineOpacityTransition, "nativeSetLineOpacityTransition"),
+            METHOD(&LineLayer::getLineOpacity, "nativeGetLineOpacity"),
+            METHOD(&LineLayer::getLineColorTransition, "nativeGetLineColorTransition"),
+            METHOD(&LineLayer::setLineColorTransition, "nativeSetLineColorTransition"),
+            METHOD(&LineLayer::getLineColor, "nativeGetLineColor"),
+            METHOD(&LineLayer::getLineTranslateTransition, "nativeGetLineTranslateTransition"),
+            METHOD(&LineLayer::setLineTranslateTransition, "nativeSetLineTranslateTransition"),
+            METHOD(&LineLayer::getLineTranslate, "nativeGetLineTranslate"),
+            METHOD(&LineLayer::getLineTranslateAnchor, "nativeGetLineTranslateAnchor"),
+            METHOD(&LineLayer::getLineWidthTransition, "nativeGetLineWidthTransition"),
+            METHOD(&LineLayer::setLineWidthTransition, "nativeSetLineWidthTransition"),
+            METHOD(&LineLayer::getLineWidth, "nativeGetLineWidth"),
+            METHOD(&LineLayer::getLineGapWidthTransition, "nativeGetLineGapWidthTransition"),
+            METHOD(&LineLayer::setLineGapWidthTransition, "nativeSetLineGapWidthTransition"),
+            METHOD(&LineLayer::getLineGapWidth, "nativeGetLineGapWidth"),
+            METHOD(&LineLayer::getLineOffsetTransition, "nativeGetLineOffsetTransition"),
+            METHOD(&LineLayer::setLineOffsetTransition, "nativeSetLineOffsetTransition"),
+            METHOD(&LineLayer::getLineOffset, "nativeGetLineOffset"),
+            METHOD(&LineLayer::getLineBlurTransition, "nativeGetLineBlurTransition"),
+            METHOD(&LineLayer::setLineBlurTransition, "nativeSetLineBlurTransition"),
+            METHOD(&LineLayer::getLineBlur, "nativeGetLineBlur"),
+            METHOD(&LineLayer::getLineDasharrayTransition, "nativeGetLineDasharrayTransition"),
+            METHOD(&LineLayer::setLineDasharrayTransition, "nativeSetLineDasharrayTransition"),
+            METHOD(&LineLayer::getLineDasharray, "nativeGetLineDasharray"),
+            METHOD(&LineLayer::getLinePatternTransition, "nativeGetLinePatternTransition"),
+            METHOD(&LineLayer::setLinePatternTransition, "nativeSetLinePatternTransition"),
+            METHOD(&LineLayer::getLinePattern, "nativeGetLinePattern"),
+            METHOD(&LineLayer::getLineGradient, "nativeGetLineGradient"));
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/line_layer.hpp

@@ -0,0 +1,96 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include "layer.hpp"
+#include "../transition_options.hpp"
+#include <mbgl/layermanager/line_layer_factory.hpp>
+#include <mbgl/style/layers/line_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class LineLayer : public Layer {
+public:
+    using SuperTag = Layer;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/LineLayer"; };
+
+    LineLayer(jni::JNIEnv&, jni::String&, jni::String&);
+
+    LineLayer(mbgl::style::LineLayer&);
+
+    LineLayer(std::unique_ptr<mbgl::style::LineLayer>);
+
+    ~LineLayer();
+
+    // Properties
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineCap(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineJoin(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineMiterLimit(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineRoundLimit(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineSortKey(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineOpacity(jni::JNIEnv&);
+    void setLineOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getLineOpacityTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineColor(jni::JNIEnv&);
+    void setLineColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getLineColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineTranslate(jni::JNIEnv&);
+    void setLineTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getLineTranslateTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineTranslateAnchor(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineWidth(jni::JNIEnv&);
+    void setLineWidthTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getLineWidthTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineGapWidth(jni::JNIEnv&);
+    void setLineGapWidthTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getLineGapWidthTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineOffset(jni::JNIEnv&);
+    void setLineOffsetTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getLineOffsetTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineBlur(jni::JNIEnv&);
+    void setLineBlurTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getLineBlurTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineDasharray(jni::JNIEnv&);
+    void setLineDasharrayTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getLineDasharrayTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLinePattern(jni::JNIEnv&);
+    void setLinePatternTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getLinePatternTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLineGradient(jni::JNIEnv&);
+
+}; // class LineLayer
+
+class LineJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::LineLayerFactory {
+public:
+    ~LineJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    LayerFactory* getLayerFactory() final { return this; }
+
+};  // class LineJavaLayerPeerFactory
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/raster_layer.cpp

@@ -0,0 +1,222 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include "raster_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+#include "../conversion/transition_options.hpp"
+
+#include <mbgl/style/layer_impl.hpp>
+
+namespace mbgl {
+namespace android {
+
+    inline mbgl::style::RasterLayer& toRasterLayer(mbgl::style::Layer& layer) {
+        return static_cast<mbgl::style::RasterLayer&>(layer);
+    }
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map) from the JVM side
+     */
+    RasterLayer::RasterLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
+        : Layer(std::make_unique<mbgl::style::RasterLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+    }
+
+    /**
+     * Creates a non-owning peer object (for layers currently attached to the map)
+     */
+    RasterLayer::RasterLayer(mbgl::style::RasterLayer& coreLayer) : Layer(coreLayer) {}
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map)
+     */
+    RasterLayer::RasterLayer(std::unique_ptr<mbgl::style::RasterLayer> coreLayer) : Layer(std::move(coreLayer)) {}
+
+    RasterLayer::~RasterLayer() = default;
+
+    // Property getters
+
+    jni::Local<jni::Object<>> RasterLayer::getRasterOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toRasterLayer(layer).getRasterOpacity()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> RasterLayer::getRasterOpacityTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toRasterLayer(layer).getRasterOpacityTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void RasterLayer::setRasterOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toRasterLayer(layer).setRasterOpacityTransition(options);
+    }
+
+    jni::Local<jni::Object<>> RasterLayer::getRasterHueRotate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toRasterLayer(layer).getRasterHueRotate()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> RasterLayer::getRasterHueRotateTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toRasterLayer(layer).getRasterHueRotateTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void RasterLayer::setRasterHueRotateTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toRasterLayer(layer).setRasterHueRotateTransition(options);
+    }
+
+    jni::Local<jni::Object<>> RasterLayer::getRasterBrightnessMin(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toRasterLayer(layer).getRasterBrightnessMin()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> RasterLayer::getRasterBrightnessMinTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toRasterLayer(layer).getRasterBrightnessMinTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void RasterLayer::setRasterBrightnessMinTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toRasterLayer(layer).setRasterBrightnessMinTransition(options);
+    }
+
+    jni::Local<jni::Object<>> RasterLayer::getRasterBrightnessMax(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toRasterLayer(layer).getRasterBrightnessMax()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> RasterLayer::getRasterBrightnessMaxTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toRasterLayer(layer).getRasterBrightnessMaxTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void RasterLayer::setRasterBrightnessMaxTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toRasterLayer(layer).setRasterBrightnessMaxTransition(options);
+    }
+
+    jni::Local<jni::Object<>> RasterLayer::getRasterSaturation(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toRasterLayer(layer).getRasterSaturation()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> RasterLayer::getRasterSaturationTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toRasterLayer(layer).getRasterSaturationTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void RasterLayer::setRasterSaturationTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toRasterLayer(layer).setRasterSaturationTransition(options);
+    }
+
+    jni::Local<jni::Object<>> RasterLayer::getRasterContrast(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toRasterLayer(layer).getRasterContrast()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> RasterLayer::getRasterContrastTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toRasterLayer(layer).getRasterContrastTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void RasterLayer::setRasterContrastTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toRasterLayer(layer).setRasterContrastTransition(options);
+    }
+
+    jni::Local<jni::Object<>> RasterLayer::getRasterResampling(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toRasterLayer(layer).getRasterResampling()));
+    }
+
+    jni::Local<jni::Object<>> RasterLayer::getRasterFadeDuration(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toRasterLayer(layer).getRasterFadeDuration()));
+    }
+
+
+    // RasterJavaLayerPeerFactory
+
+    RasterJavaLayerPeerFactory::~RasterJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<RasterLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> RasterJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                                   mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env, new RasterLayer(toRasterLayer(layer)));
+    }
+
+    jni::Local<jni::Object<Layer>> RasterJavaLayerPeerFactory::createJavaLayerPeer(
+        jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env,
+                              new RasterLayer(std::unique_ptr<mbgl::style::RasterLayer>(
+                                  static_cast<mbgl::style::RasterLayer*>(layer.release()))));
+    }
+
+    void RasterJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<RasterLayer>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<RasterLayer>(
+            env,
+            javaClass,
+            "nativePtr",
+            jni::MakePeer<RasterLayer, jni::String&, jni::String&>,
+            "initialize",
+            "finalize",
+            METHOD(&RasterLayer::getRasterOpacityTransition, "nativeGetRasterOpacityTransition"),
+            METHOD(&RasterLayer::setRasterOpacityTransition, "nativeSetRasterOpacityTransition"),
+            METHOD(&RasterLayer::getRasterOpacity, "nativeGetRasterOpacity"),
+            METHOD(&RasterLayer::getRasterHueRotateTransition, "nativeGetRasterHueRotateTransition"),
+            METHOD(&RasterLayer::setRasterHueRotateTransition, "nativeSetRasterHueRotateTransition"),
+            METHOD(&RasterLayer::getRasterHueRotate, "nativeGetRasterHueRotate"),
+            METHOD(&RasterLayer::getRasterBrightnessMinTransition, "nativeGetRasterBrightnessMinTransition"),
+            METHOD(&RasterLayer::setRasterBrightnessMinTransition, "nativeSetRasterBrightnessMinTransition"),
+            METHOD(&RasterLayer::getRasterBrightnessMin, "nativeGetRasterBrightnessMin"),
+            METHOD(&RasterLayer::getRasterBrightnessMaxTransition, "nativeGetRasterBrightnessMaxTransition"),
+            METHOD(&RasterLayer::setRasterBrightnessMaxTransition, "nativeSetRasterBrightnessMaxTransition"),
+            METHOD(&RasterLayer::getRasterBrightnessMax, "nativeGetRasterBrightnessMax"),
+            METHOD(&RasterLayer::getRasterSaturationTransition, "nativeGetRasterSaturationTransition"),
+            METHOD(&RasterLayer::setRasterSaturationTransition, "nativeSetRasterSaturationTransition"),
+            METHOD(&RasterLayer::getRasterSaturation, "nativeGetRasterSaturation"),
+            METHOD(&RasterLayer::getRasterContrastTransition, "nativeGetRasterContrastTransition"),
+            METHOD(&RasterLayer::setRasterContrastTransition, "nativeSetRasterContrastTransition"),
+            METHOD(&RasterLayer::getRasterContrast, "nativeGetRasterContrast"),
+            METHOD(&RasterLayer::getRasterResampling, "nativeGetRasterResampling"),
+            METHOD(&RasterLayer::getRasterFadeDuration, "nativeGetRasterFadeDuration"));
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/raster_layer.hpp

@@ -0,0 +1,74 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include "layer.hpp"
+#include "../transition_options.hpp"
+#include <mbgl/layermanager/raster_layer_factory.hpp>
+#include <mbgl/style/layers/raster_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class RasterLayer : public Layer {
+public:
+    using SuperTag = Layer;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/RasterLayer"; };
+
+    RasterLayer(jni::JNIEnv&, jni::String&, jni::String&);
+
+    RasterLayer(mbgl::style::RasterLayer&);
+
+    RasterLayer(std::unique_ptr<mbgl::style::RasterLayer>);
+
+    ~RasterLayer();
+
+    // Properties
+
+    jni::Local<jni::Object<jni::ObjectTag>> getRasterOpacity(jni::JNIEnv&);
+    void setRasterOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getRasterOpacityTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getRasterHueRotate(jni::JNIEnv&);
+    void setRasterHueRotateTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getRasterHueRotateTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getRasterBrightnessMin(jni::JNIEnv&);
+    void setRasterBrightnessMinTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getRasterBrightnessMinTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getRasterBrightnessMax(jni::JNIEnv&);
+    void setRasterBrightnessMaxTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getRasterBrightnessMaxTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getRasterSaturation(jni::JNIEnv&);
+    void setRasterSaturationTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getRasterSaturationTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getRasterContrast(jni::JNIEnv&);
+    void setRasterContrastTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getRasterContrastTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getRasterResampling(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getRasterFadeDuration(jni::JNIEnv&);
+
+}; // class RasterLayer
+
+class RasterJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::RasterLayerFactory {
+public:
+    ~RasterJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    LayerFactory* getLayerFactory() final { return this; }
+
+};  // class RasterJavaLayerPeerFactory
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/symbol_layer.cpp

@@ -0,0 +1,594 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include "symbol_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+#include "../conversion/transition_options.hpp"
+
+#include <mbgl/style/layer_impl.hpp>
+
+namespace mbgl {
+namespace android {
+
+    inline mbgl::style::SymbolLayer& toSymbolLayer(mbgl::style::Layer& layer) {
+        return static_cast<mbgl::style::SymbolLayer&>(layer);
+    }
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map) from the JVM side
+     */
+    SymbolLayer::SymbolLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
+        : Layer(std::make_unique<mbgl::style::SymbolLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+    }
+
+    /**
+     * Creates a non-owning peer object (for layers currently attached to the map)
+     */
+    SymbolLayer::SymbolLayer(mbgl::style::SymbolLayer& coreLayer) : Layer(coreLayer) {}
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map)
+     */
+    SymbolLayer::SymbolLayer(std::unique_ptr<mbgl::style::SymbolLayer> coreLayer) : Layer(std::move(coreLayer)) {}
+
+    SymbolLayer::~SymbolLayer() = default;
+
+    // Property getters
+
+    jni::Local<jni::Object<>> SymbolLayer::getSymbolPlacement(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getSymbolPlacement()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getSymbolSpacing(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getSymbolSpacing()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getSymbolAvoidEdges(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getSymbolAvoidEdges()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getSymbolSortKey(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getSymbolSortKey()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getSymbolZOrder(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getSymbolZOrder()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconAllowOverlap(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconAllowOverlap()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconIgnorePlacement(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconIgnorePlacement()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconOptional(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconOptional()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconRotationAlignment(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconRotationAlignment()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconSize(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconSize()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconTextFit(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconTextFit()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconTextFitPadding(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconTextFitPadding()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconImage(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconImage()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconRotate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconRotate()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconPadding(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconPadding()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconKeepUpright(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconKeepUpright()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconOffset(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconOffset()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconAnchor()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconPitchAlignment(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconPitchAlignment()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextPitchAlignment(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextPitchAlignment()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextRotationAlignment(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextRotationAlignment()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextField(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextField()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextFont(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextFont()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextSize(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextSize()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextMaxWidth(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextMaxWidth()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextLineHeight(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextLineHeight()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextLetterSpacing(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextLetterSpacing()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextJustify(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextJustify()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextRadialOffset(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextRadialOffset()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextVariableAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextVariableAnchor()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextAnchor()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextMaxAngle(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextMaxAngle()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextWritingMode(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextWritingMode()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextRotate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextRotate()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextPadding(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextPadding()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextKeepUpright(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextKeepUpright()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextTransform(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextTransform()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextOffset(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextOffset()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextAllowOverlap(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextAllowOverlap()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextIgnorePlacement(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextIgnorePlacement()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextOptional(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextOptional()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconOpacity()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> SymbolLayer::getIconOpacityTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toSymbolLayer(layer).getIconOpacityTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void SymbolLayer::setIconOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toSymbolLayer(layer).setIconOpacityTransition(options);
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> SymbolLayer::getIconColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toSymbolLayer(layer).getIconColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void SymbolLayer::setIconColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toSymbolLayer(layer).setIconColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconHaloColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconHaloColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> SymbolLayer::getIconHaloColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toSymbolLayer(layer).getIconHaloColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void SymbolLayer::setIconHaloColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toSymbolLayer(layer).setIconHaloColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconHaloWidth(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconHaloWidth()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> SymbolLayer::getIconHaloWidthTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toSymbolLayer(layer).getIconHaloWidthTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void SymbolLayer::setIconHaloWidthTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toSymbolLayer(layer).setIconHaloWidthTransition(options);
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconHaloBlur(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconHaloBlur()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> SymbolLayer::getIconHaloBlurTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toSymbolLayer(layer).getIconHaloBlurTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void SymbolLayer::setIconHaloBlurTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toSymbolLayer(layer).setIconHaloBlurTransition(options);
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconTranslate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconTranslate()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> SymbolLayer::getIconTranslateTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toSymbolLayer(layer).getIconTranslateTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void SymbolLayer::setIconTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toSymbolLayer(layer).setIconTranslateTransition(options);
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getIconTranslateAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getIconTranslateAnchor()));
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextOpacity(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextOpacity()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> SymbolLayer::getTextOpacityTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toSymbolLayer(layer).getTextOpacityTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void SymbolLayer::setTextOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toSymbolLayer(layer).setTextOpacityTransition(options);
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> SymbolLayer::getTextColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toSymbolLayer(layer).getTextColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void SymbolLayer::setTextColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toSymbolLayer(layer).setTextColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextHaloColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextHaloColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> SymbolLayer::getTextHaloColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toSymbolLayer(layer).getTextHaloColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void SymbolLayer::setTextHaloColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toSymbolLayer(layer).setTextHaloColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextHaloWidth(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextHaloWidth()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> SymbolLayer::getTextHaloWidthTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toSymbolLayer(layer).getTextHaloWidthTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void SymbolLayer::setTextHaloWidthTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toSymbolLayer(layer).setTextHaloWidthTransition(options);
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextHaloBlur(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextHaloBlur()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> SymbolLayer::getTextHaloBlurTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toSymbolLayer(layer).getTextHaloBlurTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void SymbolLayer::setTextHaloBlurTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toSymbolLayer(layer).setTextHaloBlurTransition(options);
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextTranslate(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextTranslate()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> SymbolLayer::getTextTranslateTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toSymbolLayer(layer).getTextTranslateTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void SymbolLayer::setTextTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toSymbolLayer(layer).setTextTranslateTransition(options);
+    }
+
+    jni::Local<jni::Object<>> SymbolLayer::getTextTranslateAnchor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toSymbolLayer(layer).getTextTranslateAnchor()));
+    }
+
+
+    // SymbolJavaLayerPeerFactory
+
+    SymbolJavaLayerPeerFactory::~SymbolJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<SymbolLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> SymbolJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                                   mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env, new SymbolLayer(toSymbolLayer(layer)));
+    }
+
+    jni::Local<jni::Object<Layer>> SymbolJavaLayerPeerFactory::createJavaLayerPeer(
+        jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env,
+                              new SymbolLayer(std::unique_ptr<mbgl::style::SymbolLayer>(
+                                  static_cast<mbgl::style::SymbolLayer*>(layer.release()))));
+    }
+
+    void SymbolJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<SymbolLayer>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<SymbolLayer>(
+            env,
+            javaClass,
+            "nativePtr",
+            jni::MakePeer<SymbolLayer, jni::String&, jni::String&>,
+            "initialize",
+            "finalize",
+            METHOD(&SymbolLayer::getSymbolPlacement, "nativeGetSymbolPlacement"),
+            METHOD(&SymbolLayer::getSymbolSpacing, "nativeGetSymbolSpacing"),
+            METHOD(&SymbolLayer::getSymbolAvoidEdges, "nativeGetSymbolAvoidEdges"),
+            METHOD(&SymbolLayer::getSymbolSortKey, "nativeGetSymbolSortKey"),
+            METHOD(&SymbolLayer::getSymbolZOrder, "nativeGetSymbolZOrder"),
+            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::getIconAnchor, "nativeGetIconAnchor"),
+            METHOD(&SymbolLayer::getIconPitchAlignment, "nativeGetIconPitchAlignment"),
+            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::getTextRadialOffset, "nativeGetTextRadialOffset"),
+            METHOD(&SymbolLayer::getTextVariableAnchor, "nativeGetTextVariableAnchor"),
+            METHOD(&SymbolLayer::getTextAnchor, "nativeGetTextAnchor"),
+            METHOD(&SymbolLayer::getTextMaxAngle, "nativeGetTextMaxAngle"),
+            METHOD(&SymbolLayer::getTextWritingMode, "nativeGetTextWritingMode"),
+            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::getIconOpacityTransition, "nativeGetIconOpacityTransition"),
+            METHOD(&SymbolLayer::setIconOpacityTransition, "nativeSetIconOpacityTransition"),
+            METHOD(&SymbolLayer::getIconOpacity, "nativeGetIconOpacity"),
+            METHOD(&SymbolLayer::getIconColorTransition, "nativeGetIconColorTransition"),
+            METHOD(&SymbolLayer::setIconColorTransition, "nativeSetIconColorTransition"),
+            METHOD(&SymbolLayer::getIconColor, "nativeGetIconColor"),
+            METHOD(&SymbolLayer::getIconHaloColorTransition, "nativeGetIconHaloColorTransition"),
+            METHOD(&SymbolLayer::setIconHaloColorTransition, "nativeSetIconHaloColorTransition"),
+            METHOD(&SymbolLayer::getIconHaloColor, "nativeGetIconHaloColor"),
+            METHOD(&SymbolLayer::getIconHaloWidthTransition, "nativeGetIconHaloWidthTransition"),
+            METHOD(&SymbolLayer::setIconHaloWidthTransition, "nativeSetIconHaloWidthTransition"),
+            METHOD(&SymbolLayer::getIconHaloWidth, "nativeGetIconHaloWidth"),
+            METHOD(&SymbolLayer::getIconHaloBlurTransition, "nativeGetIconHaloBlurTransition"),
+            METHOD(&SymbolLayer::setIconHaloBlurTransition, "nativeSetIconHaloBlurTransition"),
+            METHOD(&SymbolLayer::getIconHaloBlur, "nativeGetIconHaloBlur"),
+            METHOD(&SymbolLayer::getIconTranslateTransition, "nativeGetIconTranslateTransition"),
+            METHOD(&SymbolLayer::setIconTranslateTransition, "nativeSetIconTranslateTransition"),
+            METHOD(&SymbolLayer::getIconTranslate, "nativeGetIconTranslate"),
+            METHOD(&SymbolLayer::getIconTranslateAnchor, "nativeGetIconTranslateAnchor"),
+            METHOD(&SymbolLayer::getTextOpacityTransition, "nativeGetTextOpacityTransition"),
+            METHOD(&SymbolLayer::setTextOpacityTransition, "nativeSetTextOpacityTransition"),
+            METHOD(&SymbolLayer::getTextOpacity, "nativeGetTextOpacity"),
+            METHOD(&SymbolLayer::getTextColorTransition, "nativeGetTextColorTransition"),
+            METHOD(&SymbolLayer::setTextColorTransition, "nativeSetTextColorTransition"),
+            METHOD(&SymbolLayer::getTextColor, "nativeGetTextColor"),
+            METHOD(&SymbolLayer::getTextHaloColorTransition, "nativeGetTextHaloColorTransition"),
+            METHOD(&SymbolLayer::setTextHaloColorTransition, "nativeSetTextHaloColorTransition"),
+            METHOD(&SymbolLayer::getTextHaloColor, "nativeGetTextHaloColor"),
+            METHOD(&SymbolLayer::getTextHaloWidthTransition, "nativeGetTextHaloWidthTransition"),
+            METHOD(&SymbolLayer::setTextHaloWidthTransition, "nativeSetTextHaloWidthTransition"),
+            METHOD(&SymbolLayer::getTextHaloWidth, "nativeGetTextHaloWidth"),
+            METHOD(&SymbolLayer::getTextHaloBlurTransition, "nativeGetTextHaloBlurTransition"),
+            METHOD(&SymbolLayer::setTextHaloBlurTransition, "nativeSetTextHaloBlurTransition"),
+            METHOD(&SymbolLayer::getTextHaloBlur, "nativeGetTextHaloBlur"),
+            METHOD(&SymbolLayer::getTextTranslateTransition, "nativeGetTextTranslateTransition"),
+            METHOD(&SymbolLayer::setTextTranslateTransition, "nativeSetTextTranslateTransition"),
+            METHOD(&SymbolLayer::getTextTranslate, "nativeGetTextTranslate"),
+            METHOD(&SymbolLayer::getTextTranslateAnchor, "nativeGetTextTranslateAnchor"));
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/layers/symbol_layer.hpp

@@ -0,0 +1,180 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include "layer.hpp"
+#include "../transition_options.hpp"
+#include <mbgl/layermanager/symbol_layer_factory.hpp>
+#include <mbgl/style/layers/symbol_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class SymbolLayer : public Layer {
+public:
+    using SuperTag = Layer;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/SymbolLayer"; };
+
+    SymbolLayer(jni::JNIEnv&, jni::String&, jni::String&);
+
+    SymbolLayer(mbgl::style::SymbolLayer&);
+
+    SymbolLayer(std::unique_ptr<mbgl::style::SymbolLayer>);
+
+    ~SymbolLayer();
+
+    // Properties
+
+    jni::Local<jni::Object<jni::ObjectTag>> getSymbolPlacement(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getSymbolSpacing(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getSymbolAvoidEdges(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getSymbolSortKey(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getSymbolZOrder(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconAllowOverlap(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconIgnorePlacement(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconOptional(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconRotationAlignment(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconSize(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconTextFit(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconTextFitPadding(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconImage(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconRotate(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconPadding(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconKeepUpright(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconOffset(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconAnchor(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconPitchAlignment(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextPitchAlignment(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextRotationAlignment(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextField(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextFont(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextSize(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextMaxWidth(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextLineHeight(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextLetterSpacing(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextJustify(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextRadialOffset(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextVariableAnchor(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextAnchor(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextMaxAngle(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextWritingMode(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextRotate(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextPadding(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextKeepUpright(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextTransform(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextOffset(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextAllowOverlap(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextIgnorePlacement(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextOptional(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconOpacity(jni::JNIEnv&);
+    void setIconOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getIconOpacityTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconColor(jni::JNIEnv&);
+    void setIconColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getIconColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconHaloColor(jni::JNIEnv&);
+    void setIconHaloColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getIconHaloColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconHaloWidth(jni::JNIEnv&);
+    void setIconHaloWidthTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getIconHaloWidthTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconHaloBlur(jni::JNIEnv&);
+    void setIconHaloBlurTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getIconHaloBlurTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconTranslate(jni::JNIEnv&);
+    void setIconTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getIconTranslateTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getIconTranslateAnchor(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextOpacity(jni::JNIEnv&);
+    void setTextOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getTextOpacityTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextColor(jni::JNIEnv&);
+    void setTextColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getTextColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextHaloColor(jni::JNIEnv&);
+    void setTextHaloColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getTextHaloColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextHaloWidth(jni::JNIEnv&);
+    void setTextHaloWidthTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getTextHaloWidthTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextHaloBlur(jni::JNIEnv&);
+    void setTextHaloBlurTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getTextHaloBlurTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextTranslate(jni::JNIEnv&);
+    void setTextTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getTextTranslateTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTextTranslateAnchor(jni::JNIEnv&);
+
+}; // class SymbolLayer
+
+class SymbolJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::SymbolLayerFactory {
+public:
+    ~SymbolJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    LayerFactory* getLayerFactory() final { return this; }
+
+};  // class SymbolJavaLayerPeerFactory
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/light.cpp

@@ -0,0 +1,143 @@
+#include <mbgl/map/map.hpp>
+#include "light.hpp"
+#include "conversion/transition_options.hpp"
+#include "conversion/position.hpp"
+
+namespace mbgl {
+namespace android {
+
+Light::Light(mbgl::Map& coreMap, mbgl::style::Light& coreLight)
+    : light(coreLight) , map(&coreMap) {
+}
+
+static Light* initializeLightPeer(mbgl::Map& map, mbgl::style::Light& coreLight) {
+    return new Light(map, coreLight);
+}
+
+jni::Local<jni::Object<Light>> Light::createJavaLightPeer(jni::JNIEnv& env, Map& map, mbgl::style::Light& coreLight) {
+    std::unique_ptr<Light> peerLight = std::unique_ptr<Light>(initializeLightPeer(map, coreLight));
+    auto result = peerLight->createJavaPeer(env);
+    peerLight.release();
+    return result;
+}
+
+jni::Local<jni::Object<Light>> Light::createJavaPeer(jni::JNIEnv& env) {
+    static auto& javaClass = jni::Class<Light>::Singleton(env);
+    static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+    return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+}
+
+void Light::setAnchor(jni::JNIEnv& env, const jni::String& property) {
+    std::string anchorStr = jni::Make<std::string>(env, property);
+    if (anchorStr.compare("map") == 0) {
+        light.setAnchor(LightAnchorType::Map);
+    } else if (anchorStr.compare("viewport") == 0) {
+        light.setAnchor(LightAnchorType::Viewport);
+    }
+}
+
+jni::Local<jni::String> Light::getAnchor(jni::JNIEnv& env) {
+    auto anchorType = light.getAnchor();
+    if (anchorType == LightAnchorType::Map) {
+        return jni::Make<jni::String>(env, "map");
+    } else {
+        return jni::Make<jni::String>(env, "viewport");
+    }
+}
+
+void Light::setPosition(jni::JNIEnv& env, const jni::Object<Position>& jposition) {
+    using namespace mbgl::android::conversion;
+    auto position = *convert<mbgl::style::Position>(env, jposition);
+    light.setPosition(position);
+}
+
+jni::Local<jni::Object<Position>> Light::getPosition(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    mbgl::style::Position position = light.getPosition().asConstant();
+    return std::move(*convert<jni::Local<jni::Object<Position>>>(env, position));
+}
+
+jni::Local<jni::Object<TransitionOptions>> Light::getPositionTransition(jni::JNIEnv& env) {
+   using namespace mbgl::android::conversion;
+   mbgl::style::TransitionOptions options = light.getPositionTransition();
+   return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+}
+
+void Light::setPositionTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+   mbgl::style::TransitionOptions options;
+   options.duration.emplace(mbgl::Milliseconds(duration));
+   options.delay.emplace(mbgl::Milliseconds(delay));
+   light.setPositionTransition(options);
+}
+
+void Light::setColor(jni::JNIEnv& env, const jni::String& property) {
+    auto color = Color::parse(jni::Make<std::string>(env, property));
+    if (color) {
+        light.setColor(color.value());
+    }
+}
+
+jni::Local<jni::String> Light::getColor(jni::JNIEnv &env) {
+    auto color = light.getColor().asConstant();
+    return jni::Make<jni::String>(env, color.stringify());
+}
+
+jni::Local<jni::Object<TransitionOptions>> Light::getColorTransition(jni::JNIEnv& env) {
+   using namespace mbgl::android::conversion;
+   mbgl::style::TransitionOptions options = light.getColorTransition();
+   return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+}
+
+void Light::setColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+   mbgl::style::TransitionOptions options;
+   options.duration.emplace(mbgl::Milliseconds(duration));
+   options.delay.emplace(mbgl::Milliseconds(delay));
+   light.setColorTransition(options);
+}
+
+void Light::setIntensity(jni::JNIEnv&, jni::jfloat property) {
+    light.setIntensity(property);
+}
+
+jni::jfloat Light::getIntensity(jni::JNIEnv&) {
+    return light.getIntensity().asConstant();
+}
+
+jni::Local<jni::Object<TransitionOptions>> Light::getIntensityTransition(jni::JNIEnv& env) {
+   using namespace mbgl::android::conversion;
+   mbgl::style::TransitionOptions options = light.getIntensityTransition();
+   return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+}
+
+void Light::setIntensityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+   mbgl::style::TransitionOptions options;
+   options.duration.emplace(mbgl::Milliseconds(duration));
+   options.delay.emplace(mbgl::Milliseconds(delay));
+   light.setIntensityTransition(options);
+}
+
+void Light::registerNative(jni::JNIEnv& env) {
+    // Lookup the class
+    static auto& javaClass = jni::Class<Light>::Singleton(env);
+
+#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+    // Register the peer
+    jni::RegisterNativePeer<Light>(env, javaClass, "nativePtr",
+    METHOD(&Light::getAnchor, "nativeGetAnchor"),
+    METHOD(&Light::setAnchor, "nativeSetAnchor"),
+    METHOD(&Light::getPositionTransition, "nativeGetPositionTransition"),
+    METHOD(&Light::setPositionTransition, "nativeSetPositionTransition"),
+    METHOD(&Light::getPosition, "nativeGetPosition"),
+    METHOD(&Light::setPosition, "nativeSetPosition"),
+    METHOD(&Light::getColorTransition, "nativeGetColorTransition"),
+    METHOD(&Light::setColorTransition, "nativeSetColorTransition"),
+    METHOD(&Light::getColor, "nativeGetColor"),
+    METHOD(&Light::setColor, "nativeSetColor"),
+    METHOD(&Light::getIntensityTransition, "nativeGetIntensityTransition"),
+    METHOD(&Light::setIntensityTransition, "nativeSetIntensityTransition"),
+    METHOD(&Light::getIntensity, "nativeGetIntensity"),
+    METHOD(&Light::setIntensity, "nativeSetIntensity"));
+}
+
+} // namespace android
+} // namespace mb

MapboxGLAndroidSDK/src/cpp/style/light.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+
+#include <jni/jni.hpp>
+#include <mbgl/style/light.hpp>
+#include "transition_options.hpp"
+#include "position.hpp"
+#include <mbgl/style/types.hpp>
+#include <mbgl/style/property_value.hpp>
+
+namespace mbgl {
+namespace android {
+
+using namespace style;
+
+class Light : private mbgl::util::noncopyable {
+public:
+
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/light/Light"; };
+
+    static void registerNative(jni::JNIEnv&);
+
+    static jni::Local<jni::Object<Light>> createJavaLightPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Light&);
+
+    Light(mbgl::Map&, mbgl::style::Light&);
+
+    void setAnchor(jni::JNIEnv&, const jni::String&);
+    jni::Local<jni::String> getAnchor(jni::JNIEnv&);
+    void setPosition(jni::JNIEnv&, const jni::Object<Position>&);
+    jni::Local<jni::Object<Position>> getPosition(jni::JNIEnv&);
+    void setPositionTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getPositionTransition(jni::JNIEnv&);
+    void setColor(jni::JNIEnv&, const jni::String&);
+    jni::Local<jni::String> getColor(jni::JNIEnv&);
+    void setColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getColorTransition(jni::JNIEnv&);
+    void setIntensity(jni::JNIEnv&, jni::jfloat);
+    jni::jfloat getIntensity(jni::JNIEnv&);
+    void setIntensityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getIntensityTransition(jni::JNIEnv&);
+    jni::Local<jni::Object<Light>> createJavaPeer(jni::JNIEnv&);
+
+protected:
+
+    // Raw reference to the light
+    mbgl::style::Light& light;
+
+    // Map is set when the light is retrieved
+    mbgl::Map* map;
+};
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/position.cpp

@@ -0,0 +1,35 @@
+#include "position.hpp"
+
+namespace mbgl {
+namespace android {
+
+jni::Local<jni::Object<Position>> Position::fromPosition(jni::JNIEnv& env, jfloat radialCoordinate, jfloat azimuthalAngle, jfloat polarAngle) {
+    static auto& javaClass = jni::Class<Position>::Singleton(env);
+    static auto method = javaClass.GetStaticMethod<jni::Object<Position> (jfloat, jfloat, jfloat)>(env, "fromPosition");
+    return javaClass.Call(env, method, radialCoordinate, azimuthalAngle, polarAngle);
+}
+
+void Position::registerNative(jni::JNIEnv& env) {
+    jni::Class<Position>::Singleton(env);
+}
+
+float Position::getRadialCoordinate(jni::JNIEnv& env, const jni::Object<Position>& position) {
+    static auto& javaClass = jni::Class<Position>::Singleton(env);
+    static auto field = javaClass.GetField<jfloat>(env, "radialCoordinate");
+    return position.Get(env, field);
+}
+
+float Position::getAzimuthalAngle(jni::JNIEnv& env, const jni::Object<Position>& position) {
+    static auto& javaClass = jni::Class<Position>::Singleton(env);
+    static auto field = javaClass.GetField<jfloat>(env, "azimuthalAngle");
+    return position.Get(env, field);
+}
+
+float Position::getPolarAngle(jni::JNIEnv& env, const jni::Object<Position>& position) {
+    static auto& javaClass = jni::Class<Position>::Singleton(env);
+    static auto field = javaClass.GetField<jfloat>(env, "polarAngle");
+    return position.Get(env, field);
+}
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/position.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class Position : private mbgl::util::noncopyable {
+public:
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/light/Position"; };
+
+    static jni::Local<jni::Object<Position>> fromPosition(jni::JNIEnv&, jfloat, jfloat, jfloat);
+
+    static void registerNative(jni::JNIEnv&);
+
+    static float getRadialCoordinate(jni::JNIEnv&, const jni::Object<Position>&);
+    static float getAzimuthalAngle(jni::JNIEnv&, const jni::Object<Position>&);
+    static float getPolarAngle(jni::JNIEnv&, const jni::Object<Position>&);
+};
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/custom_geometry_source.cpp

@@ -0,0 +1,209 @@
+#include "custom_geometry_source.hpp"
+#include "attach_env.hpp"
+
+#include <mbgl/renderer/query.hpp>
+
+// Java -> C++ conversion
+#include "../android_conversion.hpp"
+#include "../conversion/filter.hpp"
+
+// C++ -> Java conversion
+#include "../../conversion/conversion.hpp"
+#include "../../conversion/collection.hpp"
+#include "../../geojson/feature.hpp"
+#include <mbgl/style/conversion/custom_geometry_source_options.hpp>
+
+#include <string>
+
+namespace mbgl {
+namespace android {
+
+    // This conversion is expected not to fail because it's used only in contexts where
+    // the value was originally a CustomGeometrySourceOptions object on the Java side. If it fails
+    // to convert, it's a bug in our serialization or Java-side static typing.
+    static style::CustomGeometrySource::Options convertCustomGeometrySourceOptions(jni::JNIEnv& env,
+                                                                                   const jni::Object<>& options,
+                                                                                   style::TileFunction fetchFn,
+                                                                                   style::TileFunction cancelFn) {
+        using namespace mbgl::style::conversion;
+        if (!options) {
+            return style::CustomGeometrySource::Options();
+        }
+        Error error;
+        optional<style::CustomGeometrySource::Options> result = convert<style::CustomGeometrySource::Options>(Value(env, options), error);
+        if (!result) {
+            throw std::logic_error(error.message);
+        }
+        result->fetchTileFunction = fetchFn;
+        result->cancelTileFunction = cancelFn;
+        return *result;
+    }
+
+    CustomGeometrySource::CustomGeometrySource(jni::JNIEnv& env,
+                                               const jni::String& sourceId,
+                                               const jni::Object<>& options)
+        : Source(env, std::make_unique<mbgl::style::CustomGeometrySource>(
+                         jni::Make<std::string>(env, sourceId),
+                         convertCustomGeometrySourceOptions(env, options,
+                                 std::bind(&CustomGeometrySource::fetchTile, this, std::placeholders::_1),
+                                 std::bind(&CustomGeometrySource::cancelTile, this, std::placeholders::_1)))) {
+    }
+
+    CustomGeometrySource::CustomGeometrySource(jni::JNIEnv& env,
+                                               mbgl::style::Source& coreSource,
+                                               AndroidRendererFrontend* frontend)
+        : Source(env, coreSource, createJavaPeer(env), frontend) {}
+
+    CustomGeometrySource::~CustomGeometrySource() {
+        releaseThreads();
+    }
+
+    void CustomGeometrySource::fetchTile (const mbgl::CanonicalTileID& tileID) {
+        android::UniqueEnv _env = android::AttachEnv();
+
+        static auto& javaClass = jni::Class<CustomGeometrySource>::Singleton(*_env);
+        static auto fetchTile = javaClass.GetMethod<void (jni::jint, jni::jint, jni::jint)>(*_env, "fetchTile");
+
+        // The source is removed on the main thread, but it still exists on the Render thread until the frame is complete.
+        // This might cause fetchTile/cancelTile invocations when the Java thread is shutting down and the peer has already been released.
+        // See https://github.com/mapbox/mapbox-gl-native/issues/12551.
+        if(!javaPeer) {
+            return;
+        }
+
+        auto peer = jni::Cast(*_env, javaClass, javaPeer);
+        peer.Call(*_env, fetchTile, (int)tileID.z, (int)tileID.x, (int)tileID.y);
+    };
+
+    void CustomGeometrySource::cancelTile(const mbgl::CanonicalTileID& tileID) {
+        android::UniqueEnv _env = android::AttachEnv();
+
+        static auto& javaClass = jni::Class<CustomGeometrySource>::Singleton(*_env);
+        static auto cancelTile = javaClass.GetMethod<void (jni::jint, jni::jint, jni::jint)>(*_env, "cancelTile");
+
+        // The source is removed on the main thread, but it still exists on the Render thread until the frame is complete.
+        // This might cause fetchTile/cancelTile invocations when the Java thread is shutting down and the peer has already been released.
+        // See https://github.com/mapbox/mapbox-gl-native/issues/12551.
+        if(!javaPeer) {
+            return;
+        }
+
+        auto peer = jni::Cast(*_env, javaClass, javaPeer);
+        peer.Call(*_env, cancelTile, (int)tileID.z, (int)tileID.x, (int)tileID.y);
+    };
+
+    void CustomGeometrySource::startThreads() {
+        android::UniqueEnv _env = android::AttachEnv();
+
+        static auto& javaClass = jni::Class<CustomGeometrySource>::Singleton(*_env);
+        static auto startThreads = javaClass.GetMethod<void ()>(*_env, "startThreads");
+
+        assert(javaPeer);
+
+        auto peer = jni::Cast(*_env, javaClass, javaPeer);
+        peer.Call(*_env, startThreads);
+    }
+
+    void CustomGeometrySource::releaseThreads() {
+        android::UniqueEnv _env = android::AttachEnv();
+
+        static auto& javaClass = jni::Class<CustomGeometrySource>::Singleton(*_env);
+        static auto releaseThreads = javaClass.GetMethod<void ()>(*_env, "releaseThreads");
+
+        assert(javaPeer);
+
+        auto peer = jni::Cast(*_env, javaClass, javaPeer);
+        peer.Call(*_env, releaseThreads);
+    };
+
+    bool CustomGeometrySource::isCancelled(jni::jint z,
+                                                jni::jint x,
+                                                jni::jint y) {
+        android::UniqueEnv _env = android::AttachEnv();
+
+        static auto& javaClass = jni::Class<CustomGeometrySource>::Singleton(*_env);
+        static auto isCancelled = javaClass.GetMethod<jboolean (jni::jint, jni::jint, jni::jint)>(*_env, "isCancelled");
+
+        assert(javaPeer);
+
+        auto peer = jni::Cast(*_env, javaClass, javaPeer);
+        return peer.Call(*_env, isCancelled, z, x, y);
+    };
+
+    void CustomGeometrySource::setTileData(jni::JNIEnv& env,
+                                           jni::jint z,
+                                           jni::jint x,
+                                           jni::jint y,
+                                           const jni::Object<geojson::FeatureCollection>& jFeatures) {
+        using namespace mbgl::android::geojson;
+
+        // Convert the jni object
+        auto geometry = geojson::FeatureCollection::convert(env, jFeatures);
+
+        // Update the core source if not cancelled
+        if (!isCancelled(z, x ,y)) {
+            source.as<mbgl::style::CustomGeometrySource>()->CustomGeometrySource::setTileData(CanonicalTileID(z, x, y), GeoJSON(geometry));
+        }
+    }
+
+    void CustomGeometrySource::invalidateTile(jni::JNIEnv&, jni::jint z, jni::jint x, jni::jint y) {
+        source.as<mbgl::style::CustomGeometrySource>()->CustomGeometrySource::invalidateTile(CanonicalTileID(z, x, y));
+    }
+
+    void CustomGeometrySource::invalidateBounds(jni::JNIEnv& env, const jni::Object<LatLngBounds>& jBounds) {
+        auto bounds = LatLngBounds::getLatLngBounds(env, jBounds);
+        source.as<mbgl::style::CustomGeometrySource>()->CustomGeometrySource::invalidateRegion(bounds);
+    }
+
+    jni::Local<jni::Array<jni::Object<geojson::Feature>>> CustomGeometrySource::querySourceFeatures(jni::JNIEnv& env,
+                                                                        const jni::Array<jni::Object<>>& jfilter) {
+        using namespace mbgl::android::conversion;
+        using namespace mbgl::android::geojson;
+
+        std::vector<mbgl::Feature> features;
+        if (rendererFrontend) {
+            features = rendererFrontend->querySourceFeatures(source.getID(), { {},  toFilter(env, jfilter) });
+        }
+        return Feature::convert(env, features);
+    }
+
+    jni::Local<jni::Object<Source>> CustomGeometrySource::createJavaPeer(jni::JNIEnv& env) {
+        static auto& javaClass = jni::Class<CustomGeometrySource>::Singleton(env);
+        static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+        return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+    }
+
+    void CustomGeometrySource::addToMap(JNIEnv& env, const jni::Object<Source>& obj, mbgl::Map& map, AndroidRendererFrontend& frontend) {
+        Source::addToMap(env, obj, map, frontend);
+        startThreads();
+    }
+
+    bool CustomGeometrySource::removeFromMap(JNIEnv& env, const jni::Object<Source>& source, mbgl::Map& map) {
+        bool successfullyRemoved = Source::removeFromMap(env, source, map);
+        if (successfullyRemoved) {
+            releaseThreads();
+        }
+        return successfullyRemoved;
+    }
+
+    void CustomGeometrySource::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<CustomGeometrySource>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<CustomGeometrySource>(
+            env, javaClass, "nativePtr",
+            jni::MakePeer<CustomGeometrySource, const jni::String&, const jni::Object<>&>,
+            "initialize",
+            "finalize",
+            METHOD(&CustomGeometrySource::querySourceFeatures, "querySourceFeatures"),
+            METHOD(&CustomGeometrySource::setTileData, "nativeSetTileData"),
+            METHOD(&CustomGeometrySource::invalidateTile, "nativeInvalidateTile"),
+            METHOD(&CustomGeometrySource::invalidateBounds, "nativeInvalidateBounds")
+        );
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/custom_geometry_source.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "source.hpp"
+#include <mbgl/style/sources/custom_geometry_source.hpp>
+#include <mbgl/util/geojson.hpp>
+#include <mbgl/tile/tile_id.hpp>
+#include "../../geojson/geometry.hpp"
+#include "../../geojson/feature.hpp"
+#include "../../geojson/feature_collection.hpp"
+#include "../../geometry/lat_lng_bounds.hpp"
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class CustomGeometrySource : public Source {
+public:
+    using SuperTag = Source;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/sources/CustomGeometrySource"; };
+
+    static void registerNative(jni::JNIEnv&);
+
+    CustomGeometrySource(jni::JNIEnv&, const jni::String&, const jni::Object<>&);
+    CustomGeometrySource(jni::JNIEnv&, mbgl::style::Source&, AndroidRendererFrontend*);
+    ~CustomGeometrySource();
+
+    bool removeFromMap(JNIEnv&, const jni::Object<Source>&, mbgl::Map&) override;
+    void addToMap(JNIEnv&, const jni::Object<Source>&, mbgl::Map&, AndroidRendererFrontend&) override;
+
+    void fetchTile(const mbgl::CanonicalTileID& tileID);
+    void cancelTile(const mbgl::CanonicalTileID& tileID);
+    bool isCancelled(jni::jint z, jni::jint x, jni::jint y);
+    void startThreads();
+    void releaseThreads();
+
+private:
+    void setTileData(jni::JNIEnv& env, jni::jint z, jni::jint x, jni::jint y, const jni::Object<geojson::FeatureCollection>& jf);
+
+    void invalidateTile(jni::JNIEnv& env, jni::jint z, jni::jint x, jni::jint y);
+    void invalidateBounds(jni::JNIEnv& env, const jni::Object<LatLngBounds>& bounds);
+
+    jni::Local<jni::Array<jni::Object<geojson::Feature>>> querySourceFeatures(jni::JNIEnv&,
+                                                                  const jni::Array<jni::Object<>>& );
+
+    jni::Local<jni::Object<Source>> createJavaPeer(jni::JNIEnv&);
+
+}; // class CustomGeometrySource
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/geojson_source.cpp

@@ -0,0 +1,259 @@
+#include "geojson_source.hpp"
+#include <mbgl/style/sources/geojson_source_impl.hpp>
+#include "attach_env.hpp"
+
+#include <mbgl/renderer/query.hpp>
+
+// Java -> C++ conversion
+#include "../android_conversion.hpp"
+#include "../conversion/filter.hpp"
+#include <mbgl/style/conversion/geojson.hpp>
+#include <mbgl/style/conversion/geojson_options.hpp>
+#include <mbgl/style/conversion_impl.hpp>
+
+// C++ -> Java conversion
+#include "../../conversion/conversion.hpp"
+#include "../../conversion/collection.hpp"
+#include "../../geojson/feature.hpp"
+#include "../conversion/url_or_tileset.hpp"
+
+#include <string>
+
+// GeoJSONSource uses a "coalescing" model for high frequency asynchronous data update calls,
+// which in practice means, that any update that started processing is going to finish
+// and the last scheduled update is going to finish as well. Any updates scheduled during processing can be canceled.
+// Conversion from Java features to core ones is done on a worker thread and once finished,
+// the ownership of the converted features is returned to the calling thread.
+namespace mbgl {
+namespace android {
+
+    // This conversion is expected not to fail because it's used only in contexts where
+    // the value was originally a GeoJsonOptions object on the Java side. If it fails
+    // to convert, it's a bug in our serialization or Java-side static typing.
+static Immutable<style::GeoJSONOptions> convertGeoJSONOptions(jni::JNIEnv& env, const jni::Object<>& options) {
+    using namespace mbgl::style::conversion;
+    if (!options) {
+        return style::GeoJSONOptions::defaultOptions();
+    }
+    Error error;
+    optional<style::GeoJSONOptions> result = convert<style::GeoJSONOptions>(mbgl::android::Value(env, options), error);
+    if (!result) {
+        throw std::logic_error(error.message);
+    }
+    return makeMutable<style::GeoJSONOptions>(std::move(*result));
+}
+
+GeoJSONSource::GeoJSONSource(jni::JNIEnv& env, const jni::String& sourceId, const jni::Object<>& options)
+    : Source(env,
+             std::make_unique<mbgl::style::GeoJSONSource>(jni::Make<std::string>(env, sourceId),
+                                                          convertGeoJSONOptions(env, options))),
+      converter(std::make_unique<Actor<FeatureConverter>>(Scheduler::GetBackground(),
+                                                          source.as<style::GeoJSONSource>()->impl().getOptions())) {}
+
+GeoJSONSource::GeoJSONSource(jni::JNIEnv& env, mbgl::style::Source& coreSource, AndroidRendererFrontend* frontend)
+    : Source(env, coreSource, createJavaPeer(env), frontend),
+      converter(std::make_unique<Actor<FeatureConverter>>(Scheduler::GetBackground(),
+                                                          source.as<style::GeoJSONSource>()->impl().getOptions())) {}
+
+GeoJSONSource::~GeoJSONSource() = default;
+
+void GeoJSONSource::setGeoJSONString(jni::JNIEnv& env, const jni::String& jString) {
+    std::shared_ptr<std::string> json = std::make_shared<std::string>(jni::Make<std::string>(env, jString));
+
+    Update::Converter converterFn = [this, json](ActorRef<GeoJSONDataCallback> _callback) {
+        converter->self().invoke(&FeatureConverter::convertJson, json, _callback);
+    };
+
+    setAsync(converterFn);
+}
+
+    void GeoJSONSource::setFeatureCollection(jni::JNIEnv& env, const jni::Object<geojson::FeatureCollection>& jFeatures) {
+        setCollectionAsync(env, jFeatures);
+    }
+
+    void GeoJSONSource::setFeature(jni::JNIEnv& env, const jni::Object<geojson::Feature>& jFeature) {
+        setCollectionAsync(env, jFeature);
+    }
+
+    void GeoJSONSource::setGeometry(jni::JNIEnv& env, const jni::Object<geojson::Geometry>& jGeometry) {
+        setCollectionAsync(env, jGeometry);
+    }
+
+    void GeoJSONSource::setURL(jni::JNIEnv& env, const jni::String& url) {
+        // Update the core source
+        source.as<style::GeoJSONSource>()->setURL(jni::Make<std::string>(env, url));
+    }
+
+    jni::Local<jni::String> GeoJSONSource::getURL(jni::JNIEnv& env) {
+        optional<std::string> url = source.as<style::GeoJSONSource>()->getURL();
+        return url ? jni::Make<jni::String>(env, *url) : jni::Local<jni::String>();
+    }
+
+    jni::Local<jni::Array<jni::Object<geojson::Feature>>> GeoJSONSource::querySourceFeatures(jni::JNIEnv& env,
+                                                                        const jni::Array<jni::Object<>>& jfilter) {
+        using namespace mbgl::android::conversion;
+        using namespace mbgl::android::geojson;
+
+        std::vector<mbgl::Feature> features;
+        if (rendererFrontend) {
+            features = rendererFrontend->querySourceFeatures(source.getID(),
+                { {}, toFilter(env, jfilter) });
+        }
+        return Feature::convert(env, features);
+    }
+
+    jni::Local<jni::Array<jni::Object<geojson::Feature>>> GeoJSONSource::getClusterChildren(jni::JNIEnv& env, const jni::Object<geojson::Feature>& feature) {
+        using namespace mbgl::android::conversion;
+        using namespace mbgl::android::geojson;
+
+        if (rendererFrontend) {
+            mbgl::Feature _feature = Feature::convert(env, feature);
+            _feature.properties["cluster_id"] = static_cast<uint64_t>(_feature.properties["cluster_id"].get<double>());
+            const auto featureExtension = rendererFrontend->queryFeatureExtensions(source.getID(), _feature, "supercluster", "children", {});
+            if (featureExtension.is<mbgl::FeatureCollection>()) {
+                return Feature::convert(env, featureExtension.get<mbgl::FeatureCollection>());
+            }
+        }
+        return jni::Array<jni::Object<Feature>>::New(env, 0);
+    }
+
+    jni::Local<jni::Array<jni::Object<geojson::Feature>>> GeoJSONSource::getClusterLeaves(jni::JNIEnv& env, const jni::Object<geojson::Feature>& feature, jni::jlong limit, jni::jlong offset) {
+        using namespace mbgl::android::conversion;
+        using namespace mbgl::android::geojson;
+
+        if (rendererFrontend) {
+            mbgl::Feature _feature = Feature::convert(env, feature);
+            _feature.properties["cluster_id"] = static_cast<uint64_t>(_feature.properties["cluster_id"].get<double>());
+            const std::map<std::string, mbgl::Value> options = { {"limit", static_cast<uint64_t>(limit)},
+                                                                    {"offset", static_cast<uint64_t>(offset)} };
+            auto featureExtension = rendererFrontend->queryFeatureExtensions(source.getID(), _feature, "supercluster", "leaves", options);
+            if (featureExtension.is<mbgl::FeatureCollection>()) {
+                return Feature::convert(env, featureExtension.get<mbgl::FeatureCollection>());
+            }
+        }
+        return jni::Array<jni::Object<Feature>>::New(env, 0);;
+    }
+
+    jint GeoJSONSource::getClusterExpansionZoom(jni::JNIEnv& env, const jni::Object<geojson::Feature>& feature) {
+        using namespace mbgl::android::conversion;
+        using namespace mbgl::android::geojson;
+
+        if (rendererFrontend) {
+            mbgl::Feature _feature = Feature::convert(env, feature);
+            _feature.properties["cluster_id"] = static_cast<uint64_t>(_feature.properties["cluster_id"].get<double>());
+            auto featureExtension = rendererFrontend->queryFeatureExtensions(source.getID(), _feature, "supercluster", "expansion-zoom", {});
+            if (featureExtension.is<mbgl::Value>()) {
+                auto value = featureExtension.get<mbgl::Value>();
+                if (value.is<uint64_t>()) {
+                    return value.get<uint64_t>();
+                }
+            }
+        }
+        return 0;
+    }
+
+    jni::Local<jni::Object<Source>> GeoJSONSource::createJavaPeer(jni::JNIEnv& env) {
+        static auto& javaClass = jni::Class<GeoJSONSource>::Singleton(env);
+        static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+        return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+    }
+
+    template <class JNIType>
+    void GeoJSONSource::setCollectionAsync(jni::JNIEnv& env, const jni::Object<JNIType>& jObject) {
+        auto global = jni::NewGlobal<jni::EnvAttachingDeleter>(env, jObject);
+        auto object = std::make_shared<decltype(global)>(std::move(global));
+
+        Update::Converter converterFn = [this, object](ActorRef<GeoJSONDataCallback> _callback) {
+            converter->self().invoke(&FeatureConverter::convertObject<JNIType>, object, _callback);
+        };
+
+        setAsync(converterFn);
+    }
+
+    void GeoJSONSource::setAsync(Update::Converter converterFn) {
+        awaitingUpdate = std::make_unique<Update>(
+            std::move(converterFn),
+            std::make_unique<Actor<GeoJSONDataCallback>>(
+                *Scheduler::GetCurrent(), [this](std::shared_ptr<style::GeoJSONData> geoJSONData) {
+                    // conversion from Java features to core ones finished
+                    android::UniqueEnv _env = android::AttachEnv();
+
+                    // Update the core source
+                    source.as<mbgl::style::GeoJSONSource>()->setGeoJSONData(std::move(geoJSONData));
+
+                    // if there is an awaiting update, execute it, otherwise, release resources
+                    if (awaitingUpdate) {
+                        update = std::move(awaitingUpdate);
+                        update->converterFn(update->callback->self());
+                    } else {
+                        update.reset();
+                    }
+                }));
+
+        // If another update is running, wait
+        if (update) {
+            return;
+        }
+
+        // no updates are being processed, execute this one
+        update = std::move(awaitingUpdate);
+        update->converterFn(update->callback->self());
+    }
+
+    void GeoJSONSource::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<GeoJSONSource>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<GeoJSONSource>(
+            env, javaClass, "nativePtr",
+            jni::MakePeer<GeoJSONSource, const jni::String&, const jni::Object<>&>,
+            "initialize",
+            "finalize",
+            METHOD(&GeoJSONSource::setGeoJSONString, "nativeSetGeoJsonString"),
+            METHOD(&GeoJSONSource::setFeatureCollection, "nativeSetFeatureCollection"),
+            METHOD(&GeoJSONSource::setFeature, "nativeSetFeature"),
+            METHOD(&GeoJSONSource::setGeometry, "nativeSetGeometry"),
+            METHOD(&GeoJSONSource::setURL, "nativeSetUrl"),
+            METHOD(&GeoJSONSource::getURL, "nativeGetUrl"),
+            METHOD(&GeoJSONSource::querySourceFeatures, "querySourceFeatures"),
+            METHOD(&GeoJSONSource::getClusterChildren, "nativeGetClusterChildren"),
+            METHOD(&GeoJSONSource::getClusterLeaves, "nativeGetClusterLeaves"),
+            METHOD(&GeoJSONSource::getClusterExpansionZoom, "nativeGetClusterExpansionZoom")
+        );
+    }
+
+    void FeatureConverter::convertJson(std::shared_ptr<std::string> json, ActorRef<GeoJSONDataCallback> callback) {
+        using namespace mbgl::style::conversion;
+
+        android::UniqueEnv _env = android::AttachEnv();
+        // Convert the jni object
+        Error error;
+        optional<GeoJSON> converted = parseGeoJSON(*json, error);
+        if(!converted) {
+            mbgl::Log::Error(mbgl::Event::JNI, "Error setting geo json: " + error.message);
+            return;
+        }
+
+        callback.invoke(&GeoJSONDataCallback::operator(), style::GeoJSONData::create(*converted, options));
+    }
+
+    template <class JNIType>
+    void FeatureConverter::convertObject(
+        std::shared_ptr<jni::Global<jni::Object<JNIType>, jni::EnvAttachingDeleter>> jObject,
+        ActorRef<GeoJSONDataCallback> callback) {
+        using namespace mbgl::android::geojson;
+
+        android::UniqueEnv _env = android::AttachEnv();
+        // Convert the jni object
+        auto geometry = JNIType::convert(*_env, *jObject);
+        callback.invoke(&GeoJSONDataCallback::operator(), style::GeoJSONData::create(geometry, options));
+    }
+
+    Update::Update(Converter _converterFn, std::unique_ptr<Actor<GeoJSONDataCallback>> _callback)
+        : converterFn(std::move(_converterFn)), callback(std::move(_callback)) {}
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/geojson_source.hpp

@@ -0,0 +1,79 @@
+#pragma once
+
+#include "source.hpp"
+#include <mbgl/style/sources/geojson_source.hpp>
+#include "../../geojson/geometry.hpp"
+#include "../../geojson/feature.hpp"
+#include "../../geojson/feature_collection.hpp"
+#include "../../android_renderer_frontend.hpp"
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+using GeoJSONDataCallback = std::function<void(std::shared_ptr<style::GeoJSONData>)>;
+
+class FeatureConverter {
+public:
+    explicit FeatureConverter(Immutable<style::GeoJSONOptions> options_) : options(std::move(options_)) {}
+    void convertJson(std::shared_ptr<std::string>, ActorRef<GeoJSONDataCallback>);
+
+    template <class JNIType>
+    void convertObject(std::shared_ptr<jni::Global<jni::Object<JNIType>, jni::EnvAttachingDeleter>>,
+                       ActorRef<GeoJSONDataCallback>);
+
+private:
+    Immutable<style::GeoJSONOptions> options;
+};
+
+struct Update {
+    using Converter = std::function<void(ActorRef<GeoJSONDataCallback>)>;
+    Converter converterFn;
+
+    std::unique_ptr<Actor<GeoJSONDataCallback>> callback;
+
+    Update(Converter, std::unique_ptr<Actor<GeoJSONDataCallback>>);
+};
+
+class GeoJSONSource : public Source {
+public:
+    using SuperTag = Source;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/sources/GeoJsonSource"; };
+
+    static void registerNative(jni::JNIEnv&);
+
+    GeoJSONSource(jni::JNIEnv&, const jni::String&, const jni::Object<>&);
+    GeoJSONSource(jni::JNIEnv&, mbgl::style::Source&, AndroidRendererFrontend*);
+    ~GeoJSONSource();
+
+private:
+    void setGeoJSONString(jni::JNIEnv&, const jni::String&);
+    void setFeatureCollection(jni::JNIEnv&, const jni::Object<geojson::FeatureCollection>&);
+    void setFeature(jni::JNIEnv&, const jni::Object<geojson::Feature>&);
+    void setGeometry(jni::JNIEnv&, const jni::Object<geojson::Geometry>&);
+    void setURL(jni::JNIEnv&, const jni::String&);
+
+    jni::Local<jni::Array<jni::Object<geojson::Feature>>> querySourceFeatures(jni::JNIEnv&,
+                                                                  const jni::Array<jni::Object<>>&);
+
+    jni::Local<jni::Array<jni::Object<geojson::Feature>>> getClusterChildren(jni::JNIEnv&, const jni::Object<geojson::Feature>&);
+    jni::Local<jni::Array<jni::Object<geojson::Feature>>> getClusterLeaves(jni::JNIEnv&, const jni::Object<geojson::Feature>&, jni::jlong, jni::jlong);
+    jint getClusterExpansionZoom(jni::JNIEnv&, const jni::Object<geojson::Feature>&);
+
+    jni::Local<jni::String> getURL(jni::JNIEnv&);
+
+    jni::Local<jni::Object<Source>> createJavaPeer(jni::JNIEnv&);
+    std::unique_ptr<Update> awaitingUpdate;
+    std::unique_ptr<Update> update;
+    std::shared_ptr<ThreadPool> threadPool;
+    std::unique_ptr<Actor<FeatureConverter>> converter;
+
+    template <class JNIType>
+    void setCollectionAsync(jni::JNIEnv&, const jni::Object<JNIType>&);
+
+    void setAsync(Update::Converter);
+
+}; // class GeoJSONSource
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/image_source.cpp

@@ -0,0 +1,76 @@
+#include "image_source.hpp"
+
+// Java -> C++ conversion
+#include "../android_conversion.hpp"
+
+// C++ -> Java conversion
+#include "../../conversion/conversion.hpp"
+#include <mbgl/style/conversion_impl.hpp>
+#include <mbgl/util/premultiply.hpp>
+
+#include "bitmap.hpp"
+#include <string>
+#include <array>
+
+namespace mbgl {
+namespace android {
+
+    ImageSource::ImageSource(jni::JNIEnv& env, const jni::String& sourceId, const jni::Object<LatLngQuad>& coordinatesObject)
+        : Source(env, std::make_unique<mbgl::style::ImageSource>(
+                jni::Make<std::string>(env, sourceId),
+                LatLngQuad::getLatLngArray(env, coordinatesObject)
+                )
+            ) {
+    }
+
+    ImageSource::ImageSource(jni::JNIEnv& env, mbgl::style::Source& coreSource, AndroidRendererFrontend* frontend)
+        : Source(env, coreSource, createJavaPeer(env), frontend) {}
+
+    ImageSource::~ImageSource() = default;
+
+    void ImageSource::setURL(jni::JNIEnv& env, const jni::String& url) {
+        // Update the core source
+        source.as<mbgl::style::ImageSource>()->ImageSource::setURL(jni::Make<std::string>(env, url));
+    }
+
+    jni::Local<jni::String> ImageSource::getURL(jni::JNIEnv& env) {
+        optional<std::string> url = source.as<mbgl::style::ImageSource>()->ImageSource::getURL();
+        return url ? jni::Make<jni::String>(env, *url) : jni::Local<jni::String>();
+    }
+
+    void ImageSource::setImage(jni::JNIEnv& env, const jni::Object<Bitmap>& bitmap) {
+        source.as<mbgl::style::ImageSource>()->setImage(Bitmap::GetImage(env, bitmap));
+    }
+
+    void ImageSource::setCoordinates(jni::JNIEnv& env, const jni::Object<LatLngQuad>& coordinatesObject) {
+        source.as<mbgl::style::ImageSource>()->setCoordinates(
+                LatLngQuad::getLatLngArray(env, coordinatesObject));
+    }
+
+    jni::Local<jni::Object<Source>> ImageSource::createJavaPeer(jni::JNIEnv& env) {
+        static auto& javaClass = jni::Class<ImageSource>::Singleton(env);
+        static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+        return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+    }
+
+    void ImageSource::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<ImageSource>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<ImageSource>(
+                env, javaClass, "nativePtr",
+                jni::MakePeer<ImageSource, const jni::String&, const jni::Object<LatLngQuad>&>,
+                "initialize",
+                "finalize",
+                METHOD(&ImageSource::setURL, "nativeSetUrl"),
+                METHOD(&ImageSource::getURL, "nativeGetUrl"),
+                METHOD(&ImageSource::setImage, "nativeSetImage"),
+                METHOD(&ImageSource::setCoordinates, "nativeSetCoordinates")
+        );
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/image_source.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "source.hpp"
+#include "../../geometry/lat_lng_quad.hpp"
+#include <mbgl/style/sources/image_source.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class Bitmap;
+
+class ImageSource : public Source {
+public:
+    using SuperTag = Source;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/sources/ImageSource"; };
+
+    static void registerNative(jni::JNIEnv&);
+
+    ImageSource(jni::JNIEnv&, const jni::String&, const jni::Object<LatLngQuad>&);
+
+    ImageSource(jni::JNIEnv&, mbgl::style::Source&, AndroidRendererFrontend*);
+
+    ~ImageSource();
+
+    void setURL(jni::JNIEnv&, const jni::String&);
+    jni::Local<jni::String> getURL(jni::JNIEnv&);
+
+    void setImage(jni::JNIEnv&, const jni::Object<Bitmap>&);
+
+    void setCoordinates(jni::JNIEnv&, const jni::Object<LatLngQuad>&);
+
+private:
+    jni::Local<jni::Object<Source>> createJavaPeer(jni::JNIEnv&);
+
+}; // class ImageSource
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/raster_dem_source.cpp

@@ -0,0 +1,61 @@
+#include "raster_dem_source.hpp"
+
+#include "../android_conversion.hpp"
+#include "../value.hpp"
+#include "../conversion/url_or_tileset.hpp"
+#include "source.hpp"
+
+#include <mbgl/util/variant.hpp>
+
+#include <string>
+
+namespace mbgl {
+namespace android {
+
+    RasterDEMSource::RasterDEMSource(jni::JNIEnv& env, const jni::String& sourceId, const jni::Object<>& urlOrTileSet, jni::jint tileSize)
+        : Source(
+            env,
+            std::make_unique<mbgl::style::RasterDEMSource>(
+                jni::Make<std::string>(env, sourceId),
+                convertURLOrTileset(Value(env, urlOrTileSet)),
+                tileSize
+            )
+        ) {
+    }
+
+    RasterDEMSource::RasterDEMSource(jni::JNIEnv& env,
+                                     mbgl::style::Source& coreSource,
+                                     AndroidRendererFrontend* frontend)
+        : Source(env, coreSource, createJavaPeer(env), frontend) {}
+
+    RasterDEMSource::~RasterDEMSource() = default;
+
+    jni::Local<jni::String> RasterDEMSource::getURL(jni::JNIEnv& env) {
+        optional<std::string> url = source.as<mbgl::style::RasterDEMSource>()->RasterDEMSource::getURL();
+        return url ? jni::Make<jni::String>(env, *url) : jni::Local<jni::String>();
+    }
+
+    jni::Local<jni::Object<Source>> RasterDEMSource::createJavaPeer(jni::JNIEnv& env) {
+        static auto& javaClass = jni::Class<RasterDEMSource>::Singleton(env);
+        static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+        return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+    }
+
+    void RasterDEMSource::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<RasterDEMSource>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<RasterDEMSource>(
+            env, javaClass, "nativePtr",
+            jni::MakePeer<RasterDEMSource, const jni::String&, const jni::Object<>&, jni::jint>,
+            "initialize",
+            "finalize",
+            METHOD(&RasterDEMSource::getURL, "nativeGetUrl")
+        );
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/raster_dem_source.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "source.hpp"
+#include <mbgl/style/sources/raster_dem_source.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class RasterDEMSource : public Source {
+public:
+    using SuperTag = Source;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/sources/RasterDemSource"; };
+
+    static void registerNative(jni::JNIEnv&);
+
+    RasterDEMSource(jni::JNIEnv&, const jni::String&, const jni::Object<>&, jni::jint);
+    RasterDEMSource(jni::JNIEnv&, mbgl::style::Source&, AndroidRendererFrontend*);
+    ~RasterDEMSource();
+
+    jni::Local<jni::String> getURL(jni::JNIEnv&);
+
+private:
+    jni::Local<jni::Object<Source>> createJavaPeer(jni::JNIEnv&);
+
+}; // class RasterDEMSource
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/raster_source.cpp

@@ -0,0 +1,58 @@
+#include "raster_source.hpp"
+
+#include "../android_conversion.hpp"
+#include "../value.hpp"
+#include "../conversion/url_or_tileset.hpp"
+
+#include <mbgl/util/variant.hpp>
+
+#include <string>
+
+namespace mbgl {
+namespace android {
+
+    RasterSource::RasterSource(jni::JNIEnv& env, const jni::String& sourceId, const jni::Object<>& urlOrTileSet, jni::jint tileSize)
+        : Source(
+            env,
+            std::make_unique<mbgl::style::RasterSource>(
+                jni::Make<std::string>(env, sourceId),
+                convertURLOrTileset(Value(env, urlOrTileSet)),
+                tileSize
+            )
+        ) {
+    }
+
+    RasterSource::RasterSource(jni::JNIEnv& env, mbgl::style::Source& coreSource, AndroidRendererFrontend* frontend)
+        : Source(env, coreSource, createJavaPeer(env), frontend) {}
+
+    RasterSource::~RasterSource() = default;
+
+    jni::Local<jni::String> RasterSource::getURL(jni::JNIEnv& env) {
+        optional<std::string> url = source.as<mbgl::style::RasterSource>()->RasterSource::getURL();
+        return url ? jni::Make<jni::String>(env, *url) : jni::Local<jni::String>();
+    }
+
+    jni::Local<jni::Object<Source>> RasterSource::createJavaPeer(jni::JNIEnv& env) {
+        static auto& javaClass = jni::Class<RasterSource>::Singleton(env);
+        static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+        return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+    }
+
+    void RasterSource::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<RasterSource>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<RasterSource>(
+            env, javaClass, "nativePtr",
+            jni::MakePeer<RasterSource, const jni::String&, const jni::Object<>&, jni::jint>,
+            "initialize",
+            "finalize",
+            METHOD(&RasterSource::getURL, "nativeGetUrl")
+        );
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/raster_source.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "source.hpp"
+#include <mbgl/style/sources/raster_source.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class RasterSource : public Source {
+public:
+    using SuperTag = Source;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/sources/RasterSource"; };
+
+    static void registerNative(jni::JNIEnv&);
+
+    RasterSource(jni::JNIEnv&, const jni::String&, const jni::Object<>&, jni::jint);
+    RasterSource(jni::JNIEnv&, mbgl::style::Source&, AndroidRendererFrontend*);
+    ~RasterSource();
+
+    jni::Local<jni::String> getURL(jni::JNIEnv&);
+
+private:
+    jni::Local<jni::Object<Source>> createJavaPeer(jni::JNIEnv&);
+
+}; // class RasterSource
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/source.cpp

@@ -0,0 +1,230 @@
+#include "source.hpp"
+#include "../android_conversion.hpp"
+#include "attach_env.hpp"
+
+#include <jni/jni.hpp>
+
+#include <mbgl/style/style.hpp>
+#include <mbgl/util/logging.hpp>
+
+// Java -> C++ conversion
+#include <mbgl/style/conversion/source.hpp>
+#include <mbgl/style/conversion_impl.hpp>
+
+// C++ -> Java conversion
+#include "../conversion/property_value.hpp"
+
+#include <string>
+
+// Core Sources
+#include <mbgl/style/sources/geojson_source.hpp>
+#include <mbgl/style/sources/image_source.hpp>
+#include <mbgl/style/sources/raster_source.hpp>
+#include <mbgl/style/sources/vector_source.hpp>
+
+// Android Source peers
+#include "geojson_source.hpp"
+#include "image_source.hpp"
+#include "raster_source.hpp"
+#include "unknown_source.hpp"
+#include "vector_source.hpp"
+#include "custom_geometry_source.hpp"
+#include "raster_dem_source.hpp"
+
+namespace mbgl {
+namespace android {
+
+static std::unique_ptr<Source> createSourcePeer(jni::JNIEnv& env,
+                                                mbgl::style::Source& coreSource,
+                                                AndroidRendererFrontend* frontend) {
+    if (coreSource.is<mbgl::style::VectorSource>()) {
+        return std::make_unique<VectorSource>(env, *coreSource.as<mbgl::style::VectorSource>(), frontend);
+    } else if (coreSource.is<mbgl::style::RasterSource>()) {
+        return std::make_unique<RasterSource>(env, *coreSource.as<mbgl::style::RasterSource>(), frontend);
+    } else if (coreSource.is<mbgl::style::GeoJSONSource>()) {
+        return std::make_unique<GeoJSONSource>(env, *coreSource.as<mbgl::style::GeoJSONSource>(), frontend);
+    } else if (coreSource.is<mbgl::style::ImageSource>()) {
+        return std::make_unique<ImageSource>(env, *coreSource.as<mbgl::style::ImageSource>(), frontend);
+    } else {
+        return std::make_unique<UnknownSource>(env, coreSource, frontend);
+    }
+}
+
+    const jni::Object<Source>& Source::peerForCoreSource(jni::JNIEnv& env, mbgl::style::Source& coreSource, AndroidRendererFrontend& frontend) {
+        if (!coreSource.peer.has_value()) {
+            coreSource.peer = createSourcePeer(env, coreSource, &frontend);
+        }
+        return coreSource.peer.get<std::unique_ptr<Source>>()->javaPeer;
+    }
+
+    const jni::Object<Source>& Source::peerForCoreSource(jni::JNIEnv& env, mbgl::style::Source& coreSource) {
+        if (!coreSource.peer.has_value()) {
+            coreSource.peer = createSourcePeer(env, coreSource, nullptr);
+        }
+        return coreSource.peer.get<std::unique_ptr<Source>>()->javaPeer;
+    }
+
+    Source::Source(jni::JNIEnv& env,
+                   mbgl::style::Source& coreSource,
+                   const jni::Object<Source>& obj,
+                   AndroidRendererFrontend* frontend)
+        : source(coreSource), javaPeer(jni::NewGlobal(env, obj)), rendererFrontend(frontend) {}
+
+    Source::Source(jni::JNIEnv&, std::unique_ptr<mbgl::style::Source> coreSource)
+        : ownedSource(std::move(coreSource))
+        , source(*ownedSource) {
+    }
+
+    Source::~Source() {
+        // Before being added to a map, the Java peer owns this C++ peer and cleans
+        //  up after itself correctly through the jni native peer bindings.
+        // After being added to the map, the ownership is flipped and the C++ peer has a strong reference
+        //  to it's Java peer, preventing the Java peer from being GC'ed.
+        //  In this case, the core source initiates the destruction, which requires releasing the Java peer,
+        //  while also resetting it's nativePtr to 0 to prevent the subsequent GC of the Java peer from
+        //  re-entering this dtor.
+        if (ownedSource.get() == nullptr && javaPeer.get() != nullptr) {
+            // Manually clear the java peer
+            android::UniqueEnv env = android::AttachEnv();
+            static auto& javaClass = jni::Class<Source>::Singleton(*env);
+            static auto nativePtrField = javaClass.GetField<jlong>(*env, "nativePtr");
+            javaPeer.Set(*env, nativePtrField, (jlong) 0);
+            javaPeer.reset();
+        }
+    }
+
+    jni::Local<jni::String> Source::getId(jni::JNIEnv& env) {
+        return jni::Make<jni::String>(env, source.getID());
+    }
+
+    jni::Local<jni::String> Source::getAttribution(jni::JNIEnv& env) {
+        auto attribution = source.getAttribution();
+        return attribution ? jni::Make<jni::String>(env, attribution.value()) : jni::Make<jni::String>(env,"");
+    }
+
+    void Source::setPrefetchZoomDelta(jni::JNIEnv& env, jni::Integer& delta) {
+        if (!delta) {
+            source.setPrefetchZoomDelta(nullopt);
+        } else {
+            source.setPrefetchZoomDelta(jni::Unbox(env, delta));
+        }
+    }
+
+    jni::Local<jni::Integer> Source::getPrefetchZoomDelta(jni::JNIEnv& env) {
+        auto delta = source.getPrefetchZoomDelta();
+        if (delta.has_value()) {
+            return jni::Box(env, jni::jint(delta.value()));
+        }
+        return jni::Local<jni::Integer>(env, nullptr);
+    }
+
+    void Source::setMaxOverscaleFactorForParentTiles(jni::JNIEnv& env, jni::Integer& maxOverscaleFactor) {
+        if (!maxOverscaleFactor) {
+            source.setMaxOverscaleFactorForParentTiles(nullopt);
+        } else {
+            source.setMaxOverscaleFactorForParentTiles(jni::Unbox(env, maxOverscaleFactor));
+        }
+    }
+
+    jni::Local<jni::Integer> Source::getMaxOverscaleFactorForParentTiles(jni::JNIEnv& env) {
+        auto maxOverscaleFactor = source.getMaxOverscaleFactorForParentTiles();
+        if (maxOverscaleFactor) {
+            return jni::Box(env, jni::jint(*maxOverscaleFactor));
+        }
+        return jni::Local<jni::Integer>(env, nullptr);
+    }
+
+    void Source::addToStyle(JNIEnv& env, const jni::Object<Source>& obj, mbgl::style::Style& style) {
+        if (!ownedSource) {
+            throw std::runtime_error("Cannot add source twice");
+        }
+
+        // Add source to style and release ownership
+        style.addSource(std::move(ownedSource));
+
+        // Add peer to core source
+        source.peer = std::unique_ptr<Source>(this);
+
+        // Add strong reference to java source
+        javaPeer = jni::NewGlobal(env, obj);
+    }
+
+    void Source::addToMap(JNIEnv& env, const jni::Object<Source>& obj, mbgl::Map& map, AndroidRendererFrontend& frontend) {
+        // Check to see if we own the source first
+        if (!ownedSource) {
+            throw std::runtime_error("Cannot add source twice");
+        }
+
+        // Add source to map and release ownership
+        map.getStyle().addSource(std::move(ownedSource));
+
+        // Add peer to core source
+        source.peer = std::unique_ptr<Source>(this);
+
+        // Add strong reference to java source
+        javaPeer = jni::NewGlobal(env, obj);
+
+        rendererFrontend = &frontend;
+    }
+
+    bool Source::removeFromMap(JNIEnv&, const jni::Object<Source>&, mbgl::Map& map) {
+        // Cannot remove if not attached yet
+        if (ownedSource) {
+            throw std::runtime_error("Cannot remove detached source");
+        }
+
+        // Remove the source from the map and take ownership
+        ownedSource = map.getStyle().removeSource(source.getID());
+
+        // The source may not be removed if any layers still reference it
+        return ownedSource != nullptr;
+    }
+
+    void Source::releaseJavaPeer() {
+        // We can't release the peer if the source was not removed from the map
+        if (!ownedSource) {
+            return;
+        }
+
+        // Release the peer relationships. These will be re-established when the source is added to a map
+        assert(ownedSource->peer.has_value());
+        ownedSource->peer.get<std::unique_ptr<Source>>().release();
+        ownedSource->peer = mapbox::base::TypeWrapper();
+
+        // Release the strong reference to the java peer
+        assert(javaPeer);
+        javaPeer.release();
+
+        rendererFrontend = nullptr;
+    }
+
+    void Source::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<Source>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<Source>(
+            env,
+            javaClass,
+            "nativePtr",
+            METHOD(&Source::getId, "nativeGetId"),
+            METHOD(&Source::getAttribution, "nativeGetAttribution"),
+            METHOD(&Source::setPrefetchZoomDelta, "nativeSetPrefetchZoomDelta"),
+            METHOD(&Source::getPrefetchZoomDelta, "nativeGetPrefetchZoomDelta"),
+            METHOD(&Source::setMaxOverscaleFactorForParentTiles, "nativeSetMaxOverscaleFactorForParentTiles"),
+            METHOD(&Source::getMaxOverscaleFactorForParentTiles, "nativeGetMaxOverscaleFactorForParentTiles"));
+
+        // Register subclasses
+        GeoJSONSource::registerNative(env);
+        ImageSource::registerNative(env);
+        RasterSource::registerNative(env);
+        UnknownSource::registerNative(env);
+        VectorSource::registerNative(env);
+        CustomGeometrySource::registerNative(env);
+        RasterDEMSource::registerNative(env);
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/source.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+#include <mbgl/map/map.hpp>
+#include <mbgl/style/source.hpp>
+
+#include "../value.hpp"
+#include "../../android_renderer_frontend.hpp"
+
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class Source : private mbgl::util::noncopyable {
+public:
+
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/sources/Source"; };
+
+    static void registerNative(jni::JNIEnv&);
+
+    static const jni::Object<Source>& peerForCoreSource(jni::JNIEnv&, mbgl::style::Source&);
+    static const jni::Object<Source>& peerForCoreSource(jni::JNIEnv&, mbgl::style::Source&, AndroidRendererFrontend&);
+
+    /*
+     * Called when a Java object is created for a core source that belongs to a map.
+     */
+    Source(jni::JNIEnv&, mbgl::style::Source&, const jni::Object<Source>&, AndroidRendererFrontend*);
+
+    /*
+     * Called when a Java object is created for a new core source that does not belong to a map.
+     */
+    Source(jni::JNIEnv&, std::unique_ptr<mbgl::style::Source>);
+
+    virtual ~Source();
+
+    virtual void addToMap(JNIEnv&, const jni::Object<Source>&, mbgl::Map&, AndroidRendererFrontend&);
+
+    virtual bool removeFromMap(JNIEnv&, const jni::Object<Source>&, mbgl::Map&);
+
+    void releaseJavaPeer();
+
+    jni::Local<jni::String> getId(jni::JNIEnv&);
+
+    jni::Local<jni::String> getAttribution(jni::JNIEnv&);
+
+    void setPrefetchZoomDelta(jni::JNIEnv& env, jni::Integer& delta);
+
+    jni::Local<jni::Integer> getPrefetchZoomDelta(jni::JNIEnv&);
+
+    void setMaxOverscaleFactorForParentTiles(jni::JNIEnv& env, jni::Integer& delta);
+
+    jni::Local<jni::Integer> getMaxOverscaleFactorForParentTiles(jni::JNIEnv&);
+
+    void addToStyle(JNIEnv& env, const jni::Object<Source>& obj, mbgl::style::Style& style);
+
+protected:
+    // Set on newly created sources until added to the map.
+    std::unique_ptr<mbgl::style::Source> ownedSource;
+
+    // Raw pointer that is valid at all times.
+    mbgl::style::Source& source;
+
+    // Set when the source is added to a map.
+    jni::Global<jni::Object<Source>> javaPeer;
+
+    // RendererFrontend pointer is valid only when added to the map.
+    AndroidRendererFrontend* rendererFrontend { nullptr };
+};
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/unknown_source.cpp

@@ -0,0 +1,40 @@
+#include "unknown_source.hpp"
+
+namespace {
+
+    // Dummy initializer (We don't support initializing this from the JVM)
+    std::unique_ptr<mbgl::android::UnknownSource> init(jni::JNIEnv&) {
+        throw std::runtime_error("UnknownSource should not be initialized from the JVM");
+    }
+
+} // namespace
+
+namespace mbgl {
+namespace android {
+
+UnknownSource::UnknownSource(jni::JNIEnv& env, mbgl::style::Source& coreSource, AndroidRendererFrontend* frontend)
+    : Source(env, coreSource, createJavaPeer(env), frontend) {}
+
+jni::Local<jni::Object<Source>> UnknownSource::createJavaPeer(jni::JNIEnv& env) {
+    static auto& javaClass = jni::Class<UnknownSource>::Singleton(env);
+    static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+    return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+}
+
+    void UnknownSource::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<UnknownSource>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<UnknownSource>(
+            env, javaClass, "nativePtr",
+            init,
+            "initialize",
+            "finalize"
+        );
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/unknown_source.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "source.hpp"
+#include <mbgl/style/source.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class UnknownSource : public Source {
+public:
+    using SuperTag = Source;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/sources/UnknownSource"; };
+
+    static void registerNative(jni::JNIEnv&);
+
+    UnknownSource(jni::JNIEnv&, mbgl::style::Source&, AndroidRendererFrontend*);
+
+    ~UnknownSource() = default;
+
+private:
+    jni::Local<jni::Object<Source>> createJavaPeer(jni::JNIEnv&);
+
+}; // class UnknownSource
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/vector_source.cpp

@@ -0,0 +1,81 @@
+#include "vector_source.hpp"
+
+#include <mbgl/renderer/query.hpp>
+
+// Java -> C++ conversion
+#include "../android_conversion.hpp"
+#include "../conversion/filter.hpp"
+
+// C++ -> Java conversion
+#include "../../conversion/conversion.hpp"
+#include "../../conversion/collection.hpp"
+#include "../../geojson/feature.hpp"
+#include "../conversion/url_or_tileset.hpp"
+
+#include <mbgl/util/variant.hpp>
+
+#include <string>
+#include <vector>
+
+namespace mbgl {
+namespace android {
+
+    VectorSource::VectorSource(jni::JNIEnv& env, const jni::String& sourceId, const jni::Object<>& urlOrTileSet)
+        : Source(
+            env,
+            std::make_unique<mbgl::style::VectorSource>(
+                jni::Make<std::string>(env, sourceId),
+                convertURLOrTileset(Value(env, urlOrTileSet))
+            )
+        ) {
+    }
+
+    VectorSource::VectorSource(jni::JNIEnv& env, mbgl::style::Source& coreSource, AndroidRendererFrontend* frontend)
+        : Source(env, coreSource, createJavaPeer(env), frontend) {}
+
+    VectorSource::~VectorSource() = default;
+
+    jni::Local<jni::String> VectorSource::getURL(jni::JNIEnv& env) {
+        optional<std::string> url = source.as<mbgl::style::VectorSource>()->VectorSource::getURL();
+        return url ? jni::Make<jni::String>(env, *url) : jni::Local<jni::String>();
+    }
+
+    jni::Local<jni::Array<jni::Object<geojson::Feature>>> VectorSource::querySourceFeatures(jni::JNIEnv& env,
+                                                                             const jni::Array<jni::String>& jSourceLayerIds,
+                                                                             const jni::Array<jni::Object<>>& jfilter) {
+        using namespace mbgl::android::conversion;
+        using namespace mbgl::android::geojson;
+
+        std::vector<mbgl::Feature> features;
+        if (rendererFrontend) {
+            features = rendererFrontend->querySourceFeatures(source.getID(),
+                { toVector(env, jSourceLayerIds), toFilter(env, jfilter) });
+        }
+        return Feature::convert(env, features);
+    }
+
+    jni::Local<jni::Object<Source>> VectorSource::createJavaPeer(jni::JNIEnv& env) {
+        static auto& javaClass = jni::Class<VectorSource>::Singleton(env);
+        static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+        return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+    }
+
+    void VectorSource::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<VectorSource>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<VectorSource>(
+            env, javaClass, "nativePtr",
+            jni::MakePeer<VectorSource, const jni::String&, const jni::Object<>&>,
+            "initialize",
+            "finalize",
+            METHOD(&VectorSource::querySourceFeatures, "querySourceFeatures"),
+            METHOD(&VectorSource::getURL, "nativeGetUrl")
+        );
+    }
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/sources/vector_source.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "source.hpp"
+#include <mbgl/style/sources/vector_source.hpp>
+#include "../../geojson/feature.hpp"
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class VectorSource : public Source {
+public:
+    using SuperTag = Source;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/sources/VectorSource"; };
+
+    static void registerNative(jni::JNIEnv&);
+
+    VectorSource(jni::JNIEnv&, const jni::String&, const jni::Object<>&);
+    VectorSource(jni::JNIEnv&, mbgl::style::Source&, AndroidRendererFrontend*);
+    ~VectorSource();
+
+private:
+    jni::Local<jni::Array<jni::Object<geojson::Feature>>> querySourceFeatures(jni::JNIEnv&, const jni::Array<jni::String>&,
+                                                                  const jni::Array<jni::Object<>>& jfilter);
+
+    jni::Local<jni::String> getURL(jni::JNIEnv&);
+
+    jni::Local<jni::Object<Source>> createJavaPeer(jni::JNIEnv&);
+
+}; // class VectorSource
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/transition_options.cpp

@@ -0,0 +1,35 @@
+#include "transition_options.hpp"
+
+namespace mbgl {
+namespace android {
+
+jni::Local<jni::Object<TransitionOptions>> TransitionOptions::fromTransitionOptions(jni::JNIEnv& env, jlong duration, jlong delay, jboolean enablePlacementTransitions) {
+    static auto& javaClass = jni::Class<TransitionOptions>::Singleton(env);
+    static auto method = javaClass.GetStaticMethod<jni::Object<TransitionOptions> (jlong, jlong, jboolean)>(env, "fromTransitionOptions");
+    return javaClass.Call(env, method, duration, delay, enablePlacementTransitions);
+}
+
+long TransitionOptions::getDuration(jni::JNIEnv& env, const jni::Object<TransitionOptions>& transitionOptions) {
+    static auto& javaClass = jni::Class<TransitionOptions>::Singleton(env);
+    static auto field = javaClass.GetField<jlong>(env, "duration");
+    return transitionOptions.Get(env, field);
+}
+
+long TransitionOptions::getDelay(jni::JNIEnv& env, const jni::Object<TransitionOptions>& transitionOptions) {
+    static auto& javaClass = jni::Class<TransitionOptions>::Singleton(env);
+    static auto field = javaClass.GetField<jlong>(env, "delay");
+    return transitionOptions.Get(env, field);
+}
+
+bool TransitionOptions::isEnablePlacementTransitions(jni::JNIEnv& env, const jni::Object<mbgl::android::TransitionOptions>& transitionOptions) {
+    static auto& javaClass = jni::Class<TransitionOptions>::Singleton(env);
+    static auto field = javaClass.GetField<jboolean >(env, "enablePlacementTransitions");
+    return transitionOptions.Get(env, field);
+}
+
+void TransitionOptions::registerNative(jni::JNIEnv& env) {
+    jni::Class<TransitionOptions>::Singleton(env);
+}
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/transition_options.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class TransitionOptions : private mbgl::util::noncopyable {
+public:
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/TransitionOptions"; };
+
+    static jni::Local<jni::Object<TransitionOptions>> fromTransitionOptions(jni::JNIEnv&, jlong duration, jlong delay, jboolean enablePlacementTransitions);
+
+    static long getDuration(jni::JNIEnv&, const jni::Object<TransitionOptions>&);
+
+    static long getDelay(jni::JNIEnv&, const jni::Object<TransitionOptions>&);
+
+    static bool isEnablePlacementTransitions(jni::JNIEnv&, const jni::Object<TransitionOptions>&);
+
+    static void registerNative(jni::JNIEnv&);
+};
+
+} // namespace android
+} // namespace mbgl

MapboxGLAndroidSDK/src/cpp/style/value.cpp

@@ -0,0 +1,83 @@
+#include "value.hpp"
+
+#include "../java_types.hpp"
+
+namespace mbgl {
+namespace android {
+    // Instance
+
+    Value::Value(jni::JNIEnv& _env, jni::Local<jni::Object<>> _value)
+        : env(_env),
+          value(std::move(_value)) {}
+
+    Value::Value(jni::JNIEnv& _env, const jni::Object<>& _value)
+        : env(_env),
+          value(jni::NewLocal(_env, _value)) {}
+
+    bool Value::isNull() const {
+        return !value;
+    }
+
+    bool Value::isArray() const {
+        return jni::IsInstanceOf(env, value.get(), *java::ObjectArray::jclass);
+    }
+
+    bool Value::isObject() const {
+        return jni::IsInstanceOf(env, value.get(), *java::Map::jclass);
+    }
+
+    bool Value::isString() const {
+        return jni::IsInstanceOf(env, value.get(), *java::String::jclass);
+    }
+
+    bool Value::isBool() const {
+        return jni::IsInstanceOf(env, value.get(), *java::Boolean::jclass);
+    }
+
+    bool Value::isNumber() const {
+        return jni::IsInstanceOf(env, value.get(), *java::Number::jclass);
+    }
+
+    std::string Value::toString() const {
+        return jni::Make<std::string>(env, jni::Cast(env, jni::Class<jni::StringTag>::Singleton(env), value));
+    }
+
+    float Value::toFloat() const {
+        return jni::CallMethod<jni::jfloat>(env, value.get(), *java::Number::floatValueMethodId);
+    }
+
+    double Value::toDouble() const {
+        return jni::CallMethod<jni::jdouble>(env, value.get(), *java::Number::doubleValueMethodId);
+    }
+
+    long Value::toLong() const {
+        return jni::CallMethod<jni::jlong>(env, value.get(), *java::Number::longValueMethodId);
+    }
+
+    bool Value::toBool() const {
+        return jni::CallMethod<jni::jboolean>(env, value.get(), *java::Boolean::booleanValueMethodId);
+    }
+
+    Value Value::get(const char* key) const {
+        jni::jobject* member = jni::CallMethod<jni::jobject*>(env, value.get(), *java::Map::getMethodId, jni::Make<jni::String>(env, std::string(key)).get());
+        return Value(env, jni::Local<jni::Object<>>(env, member));
+    }
+
+    Value Value::keyArray() const{
+        jni::jobject* set = jni::CallMethod<jni::jobject*>(env, value.get(), *java::Map::keySetMethodId);
+        jni::jobject* array = jni::CallMethod<jni::jobject*>(env, set, *java::Set::toArrayMethodId);
+        return Value(env, jni::Local<jni::Object<>>(env, array));
+    }
+
+    int Value::getLength() const {
+        auto array = (jni::jarray<jni::jobject>*) value.get();
+        return jni::GetArrayLength(env, *array);
+    }
+
+    Value Value::get(const int index) const {
+        auto array = (jni::jarray<jni::jobject>*) value.get();
+        return Value(env, jni::Local<jni::Object<>>(env, jni::GetObjectArrayElement(env, *array, index)));
+    }
+}
+}
+

MapboxGLAndroidSDK/src/cpp/style/value.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <jni/jni.hpp>
+
+#include <string>
+
+namespace mbgl {
+namespace android {
+
+class Value {
+public:
+    Value(jni::JNIEnv&, jni::Local<jni::Object<>>);
+    Value(jni::JNIEnv&, const jni::Object<>&);
+
+    Value(Value&&)                 = default;
+    Value& operator=(Value&&)      = delete;
+
+    Value(const Value&)            = delete;
+    Value& operator=(const Value&) = delete;
+
+    bool isNull() const;
+    bool isArray() const;
+    bool isObject() const;
+    bool isString() const;
+    bool isBool() const;
+    bool isNumber() const;
+
+    std::string toString() const;
+    float toFloat() const;
+    double toDouble() const;
+    long toLong() const;
+    bool toBool() const;
+    Value get(const char* key) const;
+    Value keyArray() const;
+    int getLength() const;
+    Value get(const int index ) const;
+
+    jni::JNIEnv& env;
+    jni::Local<jni::Object<>> value;
+};
+
+}
+}