Add clang-format (#1086)

Co-authored-by: mwilsnd <mwilsnd@gmail.com>

platform/android/MapboxGLAndroidSDK/src/cpp/style/android_conversion.hpp

@@ -17,25 +17,18 @@ namespace conversion {
 template <>
 class ConversionTraits<mbgl::android::Value> {
 public:
-    static bool isUndefined(const mbgl::android::Value& value) {
-        return value.isNull();
-    }
+    static bool isUndefined(const mbgl::android::Value& value) { return value.isNull(); }
 
-    static bool isArray(const mbgl::android::Value& value) {
-        return value.isArray();
-    }
+    static bool isArray(const mbgl::android::Value& value) { return value.isArray(); }
 
-    static bool isObject(const mbgl::android::Value& value) {
-        return value.isObject();
-    }
+    static bool isObject(const mbgl::android::Value& value) { return value.isObject(); }
 
     static std::size_t arrayLength(const mbgl::android::Value& value) {
-        return value.getLength();;
+        return value.getLength();
+        ;
     }
 
-    static mbgl::android::Value arrayMember(const mbgl::android::Value& value, std::size_t i) {
-        return value.get(i);
-    }
+    static mbgl::android::Value arrayMember(const mbgl::android::Value& value, std::size_t i) { return value.get(i); }
 
     static std::optional<mbgl::android::Value> objectMember(const mbgl::android::Value& value, const char* key) {
         mbgl::android::Value member = value.get(key);
@@ -51,7 +44,7 @@ public:
         assert(value.isObject());
         mbgl::android::Value keys = value.keyArray();
         std::size_t length = arrayLength(keys);
-        for(std::size_t i = 0; i < length; ++i){
+        for (std::size_t i = 0; i < length; ++i) {
             const auto k = keys.get(i).toString();
             auto v = value.get(k.c_str());
             std::optional<Error> result = fn(k, std::move(v));
@@ -99,19 +92,19 @@ public:
         if (value.isNull()) {
             return {};
         } else if (value.isBool()) {
-            return { value.toBool() };
+            return {value.toBool()};
         } else if (value.isString()) {
-            return { value.toString() };
+            return {value.toString()};
         } else if (value.isNumber()) {
-            return { value.toDouble() };
+            return {value.toDouble()};
         } else {
             return {};
         }
     }
 
-    static std::optional<GeoJSON> toGeoJSON(const mbgl::android::Value &value, Error &error) {
+    static std::optional<GeoJSON> toGeoJSON(const mbgl::android::Value& value, Error& error) {
         if (value.isNull()) {
-            error = { "no json data found" };
+            error = {"no json data found"};
             return {};
         }
 
@@ -138,8 +131,8 @@ public:
     }
 };
 
-template <class T, class...Args>
-std::optional<T> convert(mbgl::android::Value&& value, Error& error, Args&&...args) {
+template <class T, class... Args>
+std::optional<T> convert(mbgl::android::Value&& value, Error& error, Args&&... args) {
     return convert<T>(Convertible(std::move(value)), error, std::forward<Args>(args)...);
 }
 

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

@@ -11,12 +11,12 @@ namespace conversion {
 std::optional<mbgl::style::Filter> toFilter(jni::JNIEnv& env, const jni::Array<jni::Object<>>& jfilter) {
     std::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);
+        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;
 }

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

@@ -4,21 +4,24 @@ 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 {
+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 {
+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}};
+    std::array<float, 3> cartPosition{{radialCoordinate, azimuthalAngle, polarAngle}};
     mbgl::style::Position position{};
     position.set(cartPosition);
     return position;
 }
 
-}
-}
-}
+} // namespace conversion
+} // namespace android
+} // namespace mbgl

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

@@ -20,6 +20,6 @@ struct Converter<mbgl::style::Position, jni::Object<Position>> {
     Result<mbgl::style::Position> operator()(jni::JNIEnv &env, const jni::Object<Position> &value) const;
 };
 
-}
-}
-}
+} // namespace conversion
+} // namespace android
+} // namespace mbgl

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

@@ -13,7 +13,8 @@ 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 {
+    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());
     }
 };

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

@@ -17,7 +17,8 @@ namespace conversion {
 template <typename T>
 class PropertyValueEvaluator {
 public:
-    PropertyValueEvaluator(jni::JNIEnv& _env) : env(_env) {}
+    PropertyValueEvaluator(jni::JNIEnv& _env)
+        : env(_env) {}
 
     jni::Local<jni::Object<>> operator()(const mbgl::style::Undefined) const {
         return jni::Local<jni::Object<>>(env, nullptr);
@@ -51,7 +52,8 @@ struct Converter<jni::Local<jni::Object<>>, mbgl::style::PropertyValue<T>> {
  */
 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 {
+    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)));
     }

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

@@ -4,14 +4,16 @@ 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,
+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
-    );
+        (jboolean)value.enablePlacementTransitions);
 }
 
-}
-}
-}
+} // namespace conversion
+} // namespace android
+} // namespace mbgl

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

@@ -11,11 +11,12 @@ namespace mbgl {
 namespace android {
 namespace conversion {
 
-template<>
+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;
+    Result<jni::Local<jni::Object<TransitionOptions>>> operator()(jni::JNIEnv&,
+                                                                  const mbgl::style::TransitionOptions&) const;
 };
 
-}
-}
-}
+} // namespace conversion
+} // namespace android
+} // namespace mbgl

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

@@ -20,11 +20,11 @@ variant<std::string, Tileset> convertURLOrTileset(mbgl::android::Value&& value)
         if (!tileset) {
             throw std::logic_error(error.message);
         }
-        return { *tileset };
+        return {*tileset};
     } else {
-        return { *toString(convertible) };
+        return {*toString(convertible)};
     }
 }
 
-}
-}
+} // namespace android
+} // namespace mbgl

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

@@ -13,4 +13,4 @@ namespace android {
 variant<std::string, Tileset> convertURLOrTileset(mbgl::android::Value&& value);
 
 }
-}
+} // namespace mbgl

platform/android/MapboxGLAndroidSDK/src/cpp/style/formatted.cpp

@@ -24,7 +24,7 @@ jni::Local<jni::Object<Formatted>> Formatted::New(jni::JNIEnv& env, const style:
 
         if (section.fontScale) {
             double fontScale = section.fontScale.value();
-            static auto method = formattedSectionClass.GetMethod<void (jni::Number)>(env, "setFontScale");
+            static auto method = formattedSectionClass.GetMethod<void(jni::Number)>(env, "setFontScale");
             formattedSection.Call(env, method, jni::Box(env, fontScale));
         }
 
@@ -33,14 +33,14 @@ jni::Local<jni::Object<Formatted>> Formatted::New(jni::JNIEnv& env, const style:
             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");
+            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");
+            static auto method = formattedSectionClass.GetMethod<void(jni::Object<>)>(env, "setTextColor");
             formattedSection.Call(env, method, textColor);
         }
 

platform/android/MapboxGLAndroidSDK/src/cpp/style/formatted.hpp

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

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

@@ -12,136 +12,136 @@
 namespace mbgl {
 namespace android {
 
-    inline mbgl::style::BackgroundLayer& toBackgroundLayer(mbgl::style::Layer& layer) {
-        return static_cast<mbgl::style::BackgroundLayer&>(layer);
-    }
+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 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 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)) {
-    }
+/**
+ * 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;
+BackgroundLayer::~BackgroundLayer() = default;
 
-    // Property getters
+// 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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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::~BackgroundJavaLayerPeerFactory() = default;
 
-    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
 
-    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, 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()))));
+}
 
-    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);
 
-    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)
 
-        #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"));
-    }
+    // 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

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

@@ -40,7 +40,7 @@ public:
 
 }; // class BackgroundLayer
 
-class BackgroundJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::BackgroundLayerFactory {
+class BackgroundJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::BackgroundLayerFactory {
 public:
     ~BackgroundJavaLayerPeerFactory() override;
 
@@ -52,7 +52,7 @@ public:
 
     LayerFactory* getLayerFactory() final { return this; }
 
-};  // class BackgroundJavaLayerPeerFactory
+}; // class BackgroundJavaLayerPeerFactory
 
 } // namespace android
 } // namespace mbgl

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

@@ -12,265 +12,266 @@
 namespace mbgl {
 namespace android {
 
-    inline mbgl::style::CircleLayer& toCircleLayer(mbgl::style::Layer& layer) {
-        return static_cast<mbgl::style::CircleLayer&>(layer);
-    }
+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 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 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)) {
-    }
+/**
+ * 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;
+CircleLayer::~CircleLayer() = default;
 
-    // Property getters
+// Property getters
 
-    jni::Local<jni::Object<>> CircleLayer::getCircleSortKey(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleSortKey()));
-    }
+jni::Local<jni::Object<>> CircleLayer::getCircleSortKey(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleSortKey()));
+}
 
-    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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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::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::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::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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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::~CircleJavaLayerPeerFactory() = default;
 
-    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
 
-    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, 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()))));
+}
 
-    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);
 
-    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)
 
-        #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::getCircleSortKey, "nativeGetCircleSortKey"),
-            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"));
-    }
+    // Register the peer
+    jni::RegisterNativePeer<CircleLayer>(
+        env,
+        javaClass,
+        "nativePtr",
+        jni::MakePeer<CircleLayer, jni::String&, jni::String&>,
+        "initialize",
+        "finalize",
+        METHOD(&CircleLayer::getCircleSortKey, "nativeGetCircleSortKey"),
+        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

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

@@ -68,7 +68,7 @@ public:
 
 }; // class CircleLayer
 
-class CircleJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::CircleLayerFactory {
+class CircleJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::CircleLayerFactory {
 public:
     ~CircleJavaLayerPeerFactory() override;
 
@@ -80,7 +80,7 @@ public:
 
     LayerFactory* getLayerFactory() final { return this; }
 
-};  // class CircleJavaLayerPeerFactory
+}; // class CircleJavaLayerPeerFactory
 
 } // namespace android
 } // namespace mbgl

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

@@ -7,55 +7,55 @@
 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(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(mbgl::style::CustomLayer& coreLayer)
+    : Layer(coreLayer) {}
 
-    CustomLayer::CustomLayer(std::unique_ptr<mbgl::style::CustomLayer> coreLayer) : Layer(std::move(coreLayer)) {}
+CustomLayer::CustomLayer(std::unique_ptr<mbgl::style::CustomLayer> coreLayer)
+    : Layer(std::move(coreLayer)) {}
 
-    CustomLayer::~CustomLayer() = default;
+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));
-        }
-    }
+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));
+}
+} // namespace
 
-    CustomJavaLayerPeerFactory::~CustomJavaLayerPeerFactory() = default;
+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,
+                                                                               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()))));
-    }
+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);
+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)
+#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");
-    }
+    // Register the peer
+    jni::RegisterNativePeer<CustomLayer>(env,
+                                         javaClass,
+                                         "nativePtr",
+                                         jni::MakePeer<CustomLayer, const jni::String&, jni::jlong>,
+                                         "initialize",
+                                         "finalize");
+}
 
 } // namespace android
 } // namespace mbgl

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

@@ -23,7 +23,7 @@ public:
     jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
 }; // class CustomLayer
 
-class CustomJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::CustomLayerFactory {
+class CustomJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::CustomLayerFactory {
 public:
     ~CustomJavaLayerPeerFactory() override;
 
@@ -35,7 +35,7 @@ public:
 
     LayerFactory* getLayerFactory() final { return this; }
 
-};  // class CustomJavaLayerPeerFactory
+}; // class CustomJavaLayerPeerFactory
 
 } // namespace android
 } // namespace mbgl

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

@@ -12,211 +12,214 @@
 namespace mbgl {
 namespace android {
 
-    inline mbgl::style::FillExtrusionLayer& toFillExtrusionLayer(mbgl::style::Layer& layer) {
-        return static_cast<mbgl::style::FillExtrusionLayer&>(layer);
-    }
+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 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 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)) {
-    }
+/**
+ * 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;
+FillExtrusionLayer::~FillExtrusionLayer() = default;
 
-    // Property getters
+// 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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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::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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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()));
-    }
+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::~FillExtrusionJavaLayerPeerFactory() = default;
 
-    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
 
-    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, 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()))));
+}
 
-    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);
 
-    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)
 
-        #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"));
-    }
+    // 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

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

@@ -56,7 +56,7 @@ public:
 
 }; // class FillExtrusionLayer
 
-class FillExtrusionJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::FillExtrusionLayerFactory {
+class FillExtrusionJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::FillExtrusionLayerFactory {
 public:
     ~FillExtrusionJavaLayerPeerFactory() override;
 
@@ -68,7 +68,7 @@ public:
 
     LayerFactory* getLayerFactory() final { return this; }
 
-};  // class FillExtrusionJavaLayerPeerFactory
+}; // class FillExtrusionJavaLayerPeerFactory
 
 } // namespace android
 } // namespace mbgl

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

@@ -12,196 +12,197 @@
 namespace mbgl {
 namespace android {
 
-    inline mbgl::style::FillLayer& toFillLayer(mbgl::style::Layer& layer) {
-        return static_cast<mbgl::style::FillLayer&>(layer);
-    }
+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 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 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)) {
-    }
+/**
+ * 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;
+FillLayer::~FillLayer() = default;
 
-    // Property getters
+// 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::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::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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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::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<>> 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));
-    }
+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);
-    }
+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::~FillJavaLayerPeerFactory() = default;
 
-    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
 
-    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, 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()))));
+}
 
-    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);
 
-    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)
 
-        #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"));
-    }
+    // 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

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

@@ -54,7 +54,7 @@ public:
 
 }; // class FillLayer
 
-class FillJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::FillLayerFactory {
+class FillJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::FillLayerFactory {
 public:
     ~FillJavaLayerPeerFactory() override;
 
@@ -66,7 +66,7 @@ public:
 
     LayerFactory* getLayerFactory() final { return this; }
 
-};  // class FillJavaLayerPeerFactory
+}; // class FillJavaLayerPeerFactory
 
 } // namespace android
 } // namespace mbgl

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

@@ -12,152 +12,153 @@
 namespace mbgl {
 namespace android {
 
-    inline mbgl::style::HeatmapLayer& toHeatmapLayer(mbgl::style::Layer& layer) {
-        return static_cast<mbgl::style::HeatmapLayer&>(layer);
+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));
+}
 
-    /**
-     * 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))) {
-    }
+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()));
+}
 
-    /**
-     * Creates a non-owning peer object (for layers currently attached to the map)
-     */
-    HeatmapLayer::HeatmapLayer(mbgl::style::HeatmapLayer& coreLayer)
-        : Layer(coreLayer) {
-    }
+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));
+}
 
-    /**
-     * 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)) {
-    }
+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);
+}
 
-    HeatmapLayer::~HeatmapLayer() = default;
+// HeatmapJavaLayerPeerFactory
 
-    // Property getters
+HeatmapJavaLayerPeerFactory::~HeatmapJavaLayerPeerFactory() = default;
 
-    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()));
-    }
+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<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));
-    }
+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)));
+}
 
-    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<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()))));
+}
 
-    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()));
-    }
+void HeatmapJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+    // Lookup the class
+    static auto& javaClass = jni::Class<HeatmapLayer>::Singleton(env);
 
-    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()));
-    }
+#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
-    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"));
-    }
+    // 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

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

@@ -44,7 +44,7 @@ public:
 
 }; // class HeatmapLayer
 
-class HeatmapJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::HeatmapLayerFactory {
+class HeatmapJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::HeatmapLayerFactory {
 public:
     ~HeatmapJavaLayerPeerFactory() override;
 
@@ -56,7 +56,7 @@ public:
 
     LayerFactory* getLayerFactory() final { return this; }
 
-};  // class HeatmapJavaLayerPeerFactory
+}; // class HeatmapJavaLayerPeerFactory
 
 } // namespace android
 } // namespace mbgl

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

@@ -12,169 +12,172 @@
 namespace mbgl {
 namespace android {
 
-    inline mbgl::style::HillshadeLayer& toHillshadeLayer(mbgl::style::Layer& layer) {
-        return static_cast<mbgl::style::HillshadeLayer&>(layer);
-    }
+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 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 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)) {
-    }
+/**
+ * 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;
+HillshadeLayer::~HillshadeLayer() = default;
 
-    // Property getters
+// 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::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::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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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::~HillshadeJavaLayerPeerFactory() = default;
 
-    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
 
-    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, 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()))));
+}
 
-    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);
 
-    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)
 
-        #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"));
-    }
+    // 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

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

@@ -48,7 +48,7 @@ public:
 
 }; // class HillshadeLayer
 
-class HillshadeJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::HillshadeLayerFactory {
+class HillshadeJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::HillshadeLayerFactory {
 public:
     ~HillshadeJavaLayerPeerFactory() override;
 
@@ -60,7 +60,7 @@ public:
 
     LayerFactory* getLayerFactory() final { return this; }
 
-};  // class HillshadeJavaLayerPeerFactory
+}; // class HillshadeJavaLayerPeerFactory
 
 } // namespace android
 } // namespace mbgl

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

@@ -24,145 +24,145 @@
 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) {
+/**
+ * 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, std::optional<std::string> before) {
+    // Check to see if we own the layer first
+    if (!ownedLayer) {
+        throw std::runtime_error("Cannot add layer twice");
     }
 
-    /**
-     * Takes a non-owning reference. For lookup methods
-     */
-    Layer::Layer(mbgl::style::Layer& coreLayer) : layer(coreLayer) {}
+    // Add layer to map
+    style.addLayer(releaseCoreLayer(), before);
+}
 
-    Layer::~Layer() {
+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
+    std::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;
+    std::optional<Filter> converted = convert<Filter>(Value(env, jfilter), error);
+    if (!converted) {
+        mbgl::Log::Error(mbgl::Event::JNI, "Error setting filter: " + error.message);
+        return;
     }
 
-    void Layer::addToStyle(mbgl::style::Style& style, std::optional<std::string> before) {
-        // Check to see if we own the layer first
-        if (!ownedLayer) {
-            throw std::runtime_error("Cannot add layer twice");
-        }
+    layer.setFilter(std::move(*converted));
+}
 
-        // Add layer to map
-        style.addLayer(releaseCoreLayer(), before);
+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::setLayer(std::unique_ptr<mbgl::style::Layer> sourceLayer) {
-        this->ownedLayer = std::move(sourceLayer);
-    }
+void Layer::setSourceLayer(jni::JNIEnv& env, const jni::String& sourceLayer) {
+    layer.setSourceLayer(jni::Make<std::string>(env, sourceLayer));
+}
 
-    std::unique_ptr<mbgl::style::Layer> Layer::releaseCoreLayer() {
-        assert(ownedLayer != nullptr);
-        return std::move(ownedLayer);
-    }
+jni::Local<jni::String> Layer::getSourceLayer(jni::JNIEnv& env) {
+    return jni::Make<jni::String>(env, layer.getSourceLayer());
+}
 
-    jni::Local<jni::String> Layer::getId(jni::JNIEnv& env) {
-        return jni::Make<jni::String>(env, layer.getID());
-    }
+jni::Local<jni::String> Layer::getSourceId(jni::JNIEnv& env) {
+    return jni::Make<jni::String>(env, layer.getSourceID());
+}
 
-    style::Layer& Layer::get() {
-        return layer;
-    }
+jni::jfloat Layer::getMinZoom(jni::JNIEnv&) {
+    return layer.getMinZoom();
+}
 
-    void Layer::setProperty(jni::JNIEnv& env, const jni::String& jname, const jni::Object<>& jvalue) {
-        // Convert and set property
-        std::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;
-        }
-    }
+jni::jfloat Layer::getMaxZoom(jni::JNIEnv&) {
+    return layer.getMaxZoom();
+}
 
-    void Layer::setFilter(jni::JNIEnv& env, const jni::Array<jni::Object<>>& jfilter) {
-        using namespace mbgl::style;
-        using namespace mbgl::style::conversion;
+void Layer::setMinZoom(jni::JNIEnv&, jni::jfloat zoom) {
+    layer.setMinZoom(zoom);
+}
 
-        Error error;
-        std::optional<Filter> converted = convert<Filter>(Value(env, jfilter), error);
-        if (!converted) {
-            mbgl::Log::Error(mbgl::Event::JNI, "Error setting filter: " + error.message);
-            return;
-        }
+void Layer::setMaxZoom(jni::JNIEnv&, jni::jfloat zoom) {
+    layer.setMaxZoom(zoom);
+}
 
-        layer.setFilter(std::move(*converted));
-    }
+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()));
+}
 
-    jni::Local<jni::Object<gson::JsonElement>> Layer::getFilter(jni::JNIEnv& env) {
-        using namespace mbgl::style;
-        using namespace mbgl::style::conversion;
+void Layer::registerNative(jni::JNIEnv& env) {
+    // Lookup the class
+    static auto& javaClass = jni::Class<Layer>::Singleton(env);
 
-        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);
-        }
-    }
+#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
-    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"));
-    }
+    // 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

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

@@ -15,7 +15,6 @@ namespace android {
 
 class Layer {
 public:
-
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/Layer"; };
 
     static void registerNative(jni::JNIEnv&);
@@ -106,12 +105,11 @@ public:
 
     /**
      * @brief Get the corresponding layer factory.
-     * 
+     *
      * @return style::LayerFactory* must not be \c nullptr.
      */
     virtual LayerFactory* getLayerFactory() = 0;
 };
 
-
 } // namespace android
 } // namespace mbgl

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

@@ -102,7 +102,7 @@ void LayerManagerAndroid::registerNative(jni::JNIEnv& env) {
     }
 
     Layer::registerNative(env);
-    for (const auto& factory: peerFactories) {
+    for (const auto& factory : peerFactories) {
         factory->registerNative(env);
     }
 }
@@ -129,7 +129,7 @@ void LayerManagerAndroid::registerCoreFactory(mbgl::LayerFactory* factory) {
 
 JavaLayerPeerFactory* LayerManagerAndroid::getPeerFactory(const mbgl::style::LayerTypeInfo* typeInfo) {
     assert(typeInfo);
-    for (const auto& factory: peerFactories) {
+    for (const auto& factory : peerFactories) {
         if (factory->getLayerFactory()->getTypeInfo() == typeInfo) {
             return factory.get();
         }
@@ -147,7 +147,7 @@ LayerFactory* LayerManagerAndroid::getFactory(const mbgl::style::LayerTypeInfo*
         return peerFactory->getLayerFactory();
     }
 
-    for (const auto& factory: coreFactories) {
+    for (const auto& factory : coreFactories) {
         if (factory->getTypeInfo() == info) {
             return factory.get();
         }
@@ -168,7 +168,8 @@ 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)
+#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;

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

@@ -15,7 +15,8 @@ namespace mbgl {
 namespace android {
 
 /**
- * @brief A singleton class forwarding calls to the corresponding  \c JavaLayerPeerFactory instance.
+ * @brief A singleton class forwarding calls to the corresponding  \c
+ * JavaLayerPeerFactory instance.
  */
 class LayerManagerAndroid final : public mbgl::LayerManager {
 public:
@@ -32,13 +33,13 @@ private:
     /**
      * @brief Enables a layer type for both JSON style and runtime API.
      */
-    void addLayerType(std::unique_ptr<JavaLayerPeerFactory>); 
+    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. 
+     * won't be added to the binary.
      */
     void addLayerTypeCoreOnly(std::unique_ptr<mbgl::LayerFactory>);
 
@@ -53,5 +54,5 @@ private:
     std::map<std::string, mbgl::LayerFactory*> typeToFactory;
 };
 
-}  // namespace android
-}  // namespace mbgl
+} // namespace android
+} // namespace mbgl

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

@@ -12,304 +12,305 @@
 namespace mbgl {
 namespace android {
 
-    inline mbgl::style::LineLayer& toLineLayer(mbgl::style::Layer& layer) {
-        return static_cast<mbgl::style::LineLayer&>(layer);
-    }
+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 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 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)) {
-    }
+/**
+ * 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;
+LineLayer::~LineLayer() = default;
 
-    // Property getters
+// 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::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::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::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::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::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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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::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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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()));
-    }
+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::~LineJavaLayerPeerFactory() = default;
 
-    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
 
-    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, 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()))));
+}
 
-    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);
 
-    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)
 
-        #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"));
-    }
+    // 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

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

@@ -78,7 +78,7 @@ public:
 
 }; // class LineLayer
 
-class LineJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::LineLayerFactory {
+class LineJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::LineLayerFactory {
 public:
     ~LineJavaLayerPeerFactory() override;
 
@@ -90,7 +90,7 @@ public:
 
     LayerFactory* getLayerFactory() final { return this; }
 
-};  // class LineJavaLayerPeerFactory
+}; // class LineJavaLayerPeerFactory
 
 } // namespace android
 } // namespace mbgl

platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/location_indicator_layer.cpp

@@ -12,256 +12,263 @@
 namespace mbgl {
 namespace android {
 
-    inline mbgl::style::LocationIndicatorLayer& toLocationIndicatorLayer(mbgl::style::Layer& layer) {
-        return static_cast<mbgl::style::LocationIndicatorLayer&>(layer);
-    }
+inline mbgl::style::LocationIndicatorLayer& toLocationIndicatorLayer(mbgl::style::Layer& layer) {
+    return static_cast<mbgl::style::LocationIndicatorLayer&>(layer);
+}
 
-    /**
-     * Creates an owning peer object (for layers not attached to the map) from the JVM side
-     */
-    LocationIndicatorLayer::LocationIndicatorLayer(jni::JNIEnv& env, jni::String& layerId)
-        : Layer(std::make_unique<mbgl::style::LocationIndicatorLayer>(jni::Make<std::string>(env, layerId))) {
-    }
+/**
+ * Creates an owning peer object (for layers not attached to the map) from the JVM side
+ */
+LocationIndicatorLayer::LocationIndicatorLayer(jni::JNIEnv& env, jni::String& layerId)
+    : Layer(std::make_unique<mbgl::style::LocationIndicatorLayer>(jni::Make<std::string>(env, layerId))) {}
 
-    /**
-     * Creates a non-owning peer object (for layers currently attached to the map)
-     */
-    LocationIndicatorLayer::LocationIndicatorLayer(mbgl::style::LocationIndicatorLayer& coreLayer)
-        : Layer(coreLayer) {
-    }
+/**
+ * Creates a non-owning peer object (for layers currently attached to the map)
+ */
+LocationIndicatorLayer::LocationIndicatorLayer(mbgl::style::LocationIndicatorLayer& coreLayer)
+    : Layer(coreLayer) {}
 
-    /**
-     * Creates an owning peer object (for layers not attached to the map)
-     */
-    LocationIndicatorLayer::LocationIndicatorLayer(std::unique_ptr<mbgl::style::LocationIndicatorLayer> coreLayer)
-        : Layer(std::move(coreLayer)) {
-    }
+/**
+ * Creates an owning peer object (for layers not attached to the map)
+ */
+LocationIndicatorLayer::LocationIndicatorLayer(std::unique_ptr<mbgl::style::LocationIndicatorLayer> coreLayer)
+    : Layer(std::move(coreLayer)) {}
 
-    LocationIndicatorLayer::~LocationIndicatorLayer() = default;
+LocationIndicatorLayer::~LocationIndicatorLayer() = default;
 
-    // Property getters
+// Property getters
 
-    jni::Local<jni::Object<>> LocationIndicatorLayer::getTopImage(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getTopImage()));
-    }
+jni::Local<jni::Object<>> LocationIndicatorLayer::getTopImage(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getTopImage()));
+}
 
-    jni::Local<jni::Object<>> LocationIndicatorLayer::getBearingImage(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getBearingImage()));
-    }
+jni::Local<jni::Object<>> LocationIndicatorLayer::getBearingImage(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getBearingImage()));
+}
 
-    jni::Local<jni::Object<>> LocationIndicatorLayer::getShadowImage(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getShadowImage()));
-    }
+jni::Local<jni::Object<>> LocationIndicatorLayer::getShadowImage(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getShadowImage()));
+}
 
-    jni::Local<jni::Object<>> LocationIndicatorLayer::getPerspectiveCompensation(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getPerspectiveCompensation()));
-    }
+jni::Local<jni::Object<>> LocationIndicatorLayer::getPerspectiveCompensation(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(
+        *convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getPerspectiveCompensation()));
+}
 
-    jni::Local<jni::Object<>> LocationIndicatorLayer::getImageTiltDisplacement(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getImageTiltDisplacement()));
-    }
+jni::Local<jni::Object<>> LocationIndicatorLayer::getImageTiltDisplacement(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(
+        *convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getImageTiltDisplacement()));
+}
 
-    jni::Local<jni::Object<>> LocationIndicatorLayer::getBearing(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getBearing()));
-    }
+jni::Local<jni::Object<>> LocationIndicatorLayer::getBearing(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getBearing()));
+}
 
-    jni::Local<jni::Object<>> LocationIndicatorLayer::getLocation(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getLocation()));
-    }
+jni::Local<jni::Object<>> LocationIndicatorLayer::getLocation(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getLocation()));
+}
 
-    jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getLocationTransition(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getLocationTransition();
-        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
-    }
+jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getLocationTransition(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getLocationTransition();
+    return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+}
 
-    void LocationIndicatorLayer::setLocationTransition(jni::JNIEnv&, jlong duration, jlong delay) {
-        mbgl::style::TransitionOptions options;
-        options.duration.emplace(mbgl::Milliseconds(duration));
-        options.delay.emplace(mbgl::Milliseconds(delay));
-        toLocationIndicatorLayer(layer).setLocationTransition(options);
-    }
+void LocationIndicatorLayer::setLocationTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+    mbgl::style::TransitionOptions options;
+    options.duration.emplace(mbgl::Milliseconds(duration));
+    options.delay.emplace(mbgl::Milliseconds(delay));
+    toLocationIndicatorLayer(layer).setLocationTransition(options);
+}
 
-    jni::Local<jni::Object<>> LocationIndicatorLayer::getAccuracyRadius(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getAccuracyRadius()));
-    }
+jni::Local<jni::Object<>> LocationIndicatorLayer::getAccuracyRadius(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getAccuracyRadius()));
+}
 
-    jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getAccuracyRadiusTransition(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getAccuracyRadiusTransition();
-        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
-    }
+jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getAccuracyRadiusTransition(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getAccuracyRadiusTransition();
+    return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+}
 
-    void LocationIndicatorLayer::setAccuracyRadiusTransition(jni::JNIEnv&, jlong duration, jlong delay) {
-        mbgl::style::TransitionOptions options;
-        options.duration.emplace(mbgl::Milliseconds(duration));
-        options.delay.emplace(mbgl::Milliseconds(delay));
-        toLocationIndicatorLayer(layer).setAccuracyRadiusTransition(options);
-    }
+void LocationIndicatorLayer::setAccuracyRadiusTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+    mbgl::style::TransitionOptions options;
+    options.duration.emplace(mbgl::Milliseconds(duration));
+    options.delay.emplace(mbgl::Milliseconds(delay));
+    toLocationIndicatorLayer(layer).setAccuracyRadiusTransition(options);
+}
 
-    jni::Local<jni::Object<>> LocationIndicatorLayer::getTopImageSize(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getTopImageSize()));
-    }
+jni::Local<jni::Object<>> LocationIndicatorLayer::getTopImageSize(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getTopImageSize()));
+}
 
-    jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getTopImageSizeTransition(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getTopImageSizeTransition();
-        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
-    }
+jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getTopImageSizeTransition(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getTopImageSizeTransition();
+    return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+}
 
-    void LocationIndicatorLayer::setTopImageSizeTransition(jni::JNIEnv&, jlong duration, jlong delay) {
-        mbgl::style::TransitionOptions options;
-        options.duration.emplace(mbgl::Milliseconds(duration));
-        options.delay.emplace(mbgl::Milliseconds(delay));
-        toLocationIndicatorLayer(layer).setTopImageSizeTransition(options);
-    }
+void LocationIndicatorLayer::setTopImageSizeTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+    mbgl::style::TransitionOptions options;
+    options.duration.emplace(mbgl::Milliseconds(duration));
+    options.delay.emplace(mbgl::Milliseconds(delay));
+    toLocationIndicatorLayer(layer).setTopImageSizeTransition(options);
+}
 
-    jni::Local<jni::Object<>> LocationIndicatorLayer::getBearingImageSize(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getBearingImageSize()));
-    }
+jni::Local<jni::Object<>> LocationIndicatorLayer::getBearingImageSize(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getBearingImageSize()));
+}
 
-    jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getBearingImageSizeTransition(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getBearingImageSizeTransition();
-        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
-    }
+jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getBearingImageSizeTransition(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getBearingImageSizeTransition();
+    return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+}
 
-    void LocationIndicatorLayer::setBearingImageSizeTransition(jni::JNIEnv&, jlong duration, jlong delay) {
-        mbgl::style::TransitionOptions options;
-        options.duration.emplace(mbgl::Milliseconds(duration));
-        options.delay.emplace(mbgl::Milliseconds(delay));
-        toLocationIndicatorLayer(layer).setBearingImageSizeTransition(options);
-    }
+void LocationIndicatorLayer::setBearingImageSizeTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+    mbgl::style::TransitionOptions options;
+    options.duration.emplace(mbgl::Milliseconds(duration));
+    options.delay.emplace(mbgl::Milliseconds(delay));
+    toLocationIndicatorLayer(layer).setBearingImageSizeTransition(options);
+}
 
-    jni::Local<jni::Object<>> LocationIndicatorLayer::getShadowImageSize(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getShadowImageSize()));
-    }
+jni::Local<jni::Object<>> LocationIndicatorLayer::getShadowImageSize(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getShadowImageSize()));
+}
 
-    jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getShadowImageSizeTransition(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getShadowImageSizeTransition();
-        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
-    }
+jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getShadowImageSizeTransition(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getShadowImageSizeTransition();
+    return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+}
 
-    void LocationIndicatorLayer::setShadowImageSizeTransition(jni::JNIEnv&, jlong duration, jlong delay) {
-        mbgl::style::TransitionOptions options;
-        options.duration.emplace(mbgl::Milliseconds(duration));
-        options.delay.emplace(mbgl::Milliseconds(delay));
-        toLocationIndicatorLayer(layer).setShadowImageSizeTransition(options);
-    }
+void LocationIndicatorLayer::setShadowImageSizeTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+    mbgl::style::TransitionOptions options;
+    options.duration.emplace(mbgl::Milliseconds(duration));
+    options.delay.emplace(mbgl::Milliseconds(delay));
+    toLocationIndicatorLayer(layer).setShadowImageSizeTransition(options);
+}
 
-    jni::Local<jni::Object<>> LocationIndicatorLayer::getAccuracyRadiusColor(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getAccuracyRadiusColor()));
-    }
+jni::Local<jni::Object<>> LocationIndicatorLayer::getAccuracyRadiusColor(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(
+        *convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getAccuracyRadiusColor()));
+}
 
-    jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getAccuracyRadiusColorTransition(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getAccuracyRadiusColorTransition();
-        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
-    }
+jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getAccuracyRadiusColorTransition(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getAccuracyRadiusColorTransition();
+    return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+}
 
-    void LocationIndicatorLayer::setAccuracyRadiusColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
-        mbgl::style::TransitionOptions options;
-        options.duration.emplace(mbgl::Milliseconds(duration));
-        options.delay.emplace(mbgl::Milliseconds(delay));
-        toLocationIndicatorLayer(layer).setAccuracyRadiusColorTransition(options);
-    }
+void LocationIndicatorLayer::setAccuracyRadiusColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+    mbgl::style::TransitionOptions options;
+    options.duration.emplace(mbgl::Milliseconds(duration));
+    options.delay.emplace(mbgl::Milliseconds(delay));
+    toLocationIndicatorLayer(layer).setAccuracyRadiusColorTransition(options);
+}
 
-    jni::Local<jni::Object<>> LocationIndicatorLayer::getAccuracyRadiusBorderColor(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getAccuracyRadiusBorderColor()));
-    }
+jni::Local<jni::Object<>> LocationIndicatorLayer::getAccuracyRadiusBorderColor(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    return std::move(
+        *convert<jni::Local<jni::Object<>>>(env, toLocationIndicatorLayer(layer).getAccuracyRadiusBorderColor()));
+}
 
-    jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getAccuracyRadiusBorderColorTransition(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getAccuracyRadiusBorderColorTransition();
-        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
-    }
+jni::Local<jni::Object<TransitionOptions>> LocationIndicatorLayer::getAccuracyRadiusBorderColorTransition(
+    jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    mbgl::style::TransitionOptions options = toLocationIndicatorLayer(layer).getAccuracyRadiusBorderColorTransition();
+    return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+}
 
-    void LocationIndicatorLayer::setAccuracyRadiusBorderColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
-        mbgl::style::TransitionOptions options;
-        options.duration.emplace(mbgl::Milliseconds(duration));
-        options.delay.emplace(mbgl::Milliseconds(delay));
-        toLocationIndicatorLayer(layer).setAccuracyRadiusBorderColorTransition(options);
-    }
+void LocationIndicatorLayer::setAccuracyRadiusBorderColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+    mbgl::style::TransitionOptions options;
+    options.duration.emplace(mbgl::Milliseconds(duration));
+    options.delay.emplace(mbgl::Milliseconds(delay));
+    toLocationIndicatorLayer(layer).setAccuracyRadiusBorderColorTransition(options);
+}
 
+// LocationIndicatorJavaLayerPeerFactory
 
-    // LocationIndicatorJavaLayerPeerFactory
+LocationIndicatorJavaLayerPeerFactory::~LocationIndicatorJavaLayerPeerFactory() = default;
 
-    LocationIndicatorJavaLayerPeerFactory::~LocationIndicatorJavaLayerPeerFactory() = default;
+namespace {
+jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+    static auto& javaClass = jni::Class<LocationIndicatorLayer>::Singleton(env);
+    static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+    return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+}
+} // namespace
 
-    namespace {
-        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
-            static auto& javaClass = jni::Class<LocationIndicatorLayer>::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>> LocationIndicatorJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                                          mbgl::style::Layer& layer) {
+    assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
+    return createJavaPeer(env, new LocationIndicatorLayer(toLocationIndicatorLayer(layer)));
+}
 
-    jni::Local<jni::Object<Layer>> LocationIndicatorJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::style::Layer& layer) {
-        assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
-        return createJavaPeer(env, new LocationIndicatorLayer(toLocationIndicatorLayer(layer)));
-    }
+jni::Local<jni::Object<Layer>> LocationIndicatorJavaLayerPeerFactory::createJavaLayerPeer(
+    jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+    assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
+    return createJavaPeer(env,
+                          new LocationIndicatorLayer(std::unique_ptr<mbgl::style::LocationIndicatorLayer>(
+                              static_cast<mbgl::style::LocationIndicatorLayer*>(layer.release()))));
+}
 
-    jni::Local<jni::Object<Layer>> LocationIndicatorJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
-        assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
-        return createJavaPeer(env, new LocationIndicatorLayer(std::unique_ptr<mbgl::style::LocationIndicatorLayer>(static_cast<mbgl::style::LocationIndicatorLayer*>(layer.release()))));
-    }
+void LocationIndicatorJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+    // Lookup the class
+    static auto& javaClass = jni::Class<LocationIndicatorLayer>::Singleton(env);
 
-    void LocationIndicatorJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
-        // Lookup the class
-        static auto& javaClass = jni::Class<LocationIndicatorLayer>::Singleton(env);
+#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
-        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
-
-        // Register the peer
-        jni::RegisterNativePeer<LocationIndicatorLayer>(
-            env,
-            javaClass,
-            "nativePtr",
-            jni::MakePeer<LocationIndicatorLayer, jni::String&>,
-            "initialize",
-            "finalize",
-            METHOD(&LocationIndicatorLayer::getTopImage, "nativeGetTopImage"),
-            METHOD(&LocationIndicatorLayer::getBearingImage, "nativeGetBearingImage"),
-            METHOD(&LocationIndicatorLayer::getShadowImage, "nativeGetShadowImage"),
-            METHOD(&LocationIndicatorLayer::getPerspectiveCompensation, "nativeGetPerspectiveCompensation"),
-            METHOD(&LocationIndicatorLayer::getImageTiltDisplacement, "nativeGetImageTiltDisplacement"),
-            METHOD(&LocationIndicatorLayer::getBearing, "nativeGetBearing"),
-            METHOD(&LocationIndicatorLayer::getLocationTransition, "nativeGetLocationTransition"),
-            METHOD(&LocationIndicatorLayer::setLocationTransition, "nativeSetLocationTransition"),
-            METHOD(&LocationIndicatorLayer::getLocation, "nativeGetLocation"),
-            METHOD(&LocationIndicatorLayer::getAccuracyRadiusTransition, "nativeGetAccuracyRadiusTransition"),
-            METHOD(&LocationIndicatorLayer::setAccuracyRadiusTransition, "nativeSetAccuracyRadiusTransition"),
-            METHOD(&LocationIndicatorLayer::getAccuracyRadius, "nativeGetAccuracyRadius"),
-            METHOD(&LocationIndicatorLayer::getTopImageSizeTransition, "nativeGetTopImageSizeTransition"),
-            METHOD(&LocationIndicatorLayer::setTopImageSizeTransition, "nativeSetTopImageSizeTransition"),
-            METHOD(&LocationIndicatorLayer::getTopImageSize, "nativeGetTopImageSize"),
-            METHOD(&LocationIndicatorLayer::getBearingImageSizeTransition, "nativeGetBearingImageSizeTransition"),
-            METHOD(&LocationIndicatorLayer::setBearingImageSizeTransition, "nativeSetBearingImageSizeTransition"),
-            METHOD(&LocationIndicatorLayer::getBearingImageSize, "nativeGetBearingImageSize"),
-            METHOD(&LocationIndicatorLayer::getShadowImageSizeTransition, "nativeGetShadowImageSizeTransition"),
-            METHOD(&LocationIndicatorLayer::setShadowImageSizeTransition, "nativeSetShadowImageSizeTransition"),
-            METHOD(&LocationIndicatorLayer::getShadowImageSize, "nativeGetShadowImageSize"),
-            METHOD(&LocationIndicatorLayer::getAccuracyRadiusColorTransition, "nativeGetAccuracyRadiusColorTransition"),
-            METHOD(&LocationIndicatorLayer::setAccuracyRadiusColorTransition, "nativeSetAccuracyRadiusColorTransition"),
-            METHOD(&LocationIndicatorLayer::getAccuracyRadiusColor, "nativeGetAccuracyRadiusColor"),
-            METHOD(&LocationIndicatorLayer::getAccuracyRadiusBorderColorTransition, "nativeGetAccuracyRadiusBorderColorTransition"),
-            METHOD(&LocationIndicatorLayer::setAccuracyRadiusBorderColorTransition, "nativeSetAccuracyRadiusBorderColorTransition"),
-            METHOD(&LocationIndicatorLayer::getAccuracyRadiusBorderColor, "nativeGetAccuracyRadiusBorderColor"));
-    }
+    // Register the peer
+    jni::RegisterNativePeer<LocationIndicatorLayer>(
+        env,
+        javaClass,
+        "nativePtr",
+        jni::MakePeer<LocationIndicatorLayer, jni::String&>,
+        "initialize",
+        "finalize",
+        METHOD(&LocationIndicatorLayer::getTopImage, "nativeGetTopImage"),
+        METHOD(&LocationIndicatorLayer::getBearingImage, "nativeGetBearingImage"),
+        METHOD(&LocationIndicatorLayer::getShadowImage, "nativeGetShadowImage"),
+        METHOD(&LocationIndicatorLayer::getPerspectiveCompensation, "nativeGetPerspectiveCompensation"),
+        METHOD(&LocationIndicatorLayer::getImageTiltDisplacement, "nativeGetImageTiltDisplacement"),
+        METHOD(&LocationIndicatorLayer::getBearing, "nativeGetBearing"),
+        METHOD(&LocationIndicatorLayer::getLocationTransition, "nativeGetLocationTransition"),
+        METHOD(&LocationIndicatorLayer::setLocationTransition, "nativeSetLocationTransition"),
+        METHOD(&LocationIndicatorLayer::getLocation, "nativeGetLocation"),
+        METHOD(&LocationIndicatorLayer::getAccuracyRadiusTransition, "nativeGetAccuracyRadiusTransition"),
+        METHOD(&LocationIndicatorLayer::setAccuracyRadiusTransition, "nativeSetAccuracyRadiusTransition"),
+        METHOD(&LocationIndicatorLayer::getAccuracyRadius, "nativeGetAccuracyRadius"),
+        METHOD(&LocationIndicatorLayer::getTopImageSizeTransition, "nativeGetTopImageSizeTransition"),
+        METHOD(&LocationIndicatorLayer::setTopImageSizeTransition, "nativeSetTopImageSizeTransition"),
+        METHOD(&LocationIndicatorLayer::getTopImageSize, "nativeGetTopImageSize"),
+        METHOD(&LocationIndicatorLayer::getBearingImageSizeTransition, "nativeGetBearingImageSizeTransition"),
+        METHOD(&LocationIndicatorLayer::setBearingImageSizeTransition, "nativeSetBearingImageSizeTransition"),
+        METHOD(&LocationIndicatorLayer::getBearingImageSize, "nativeGetBearingImageSize"),
+        METHOD(&LocationIndicatorLayer::getShadowImageSizeTransition, "nativeGetShadowImageSizeTransition"),
+        METHOD(&LocationIndicatorLayer::setShadowImageSizeTransition, "nativeSetShadowImageSizeTransition"),
+        METHOD(&LocationIndicatorLayer::getShadowImageSize, "nativeGetShadowImageSize"),
+        METHOD(&LocationIndicatorLayer::getAccuracyRadiusColorTransition, "nativeGetAccuracyRadiusColorTransition"),
+        METHOD(&LocationIndicatorLayer::setAccuracyRadiusColorTransition, "nativeSetAccuracyRadiusColorTransition"),
+        METHOD(&LocationIndicatorLayer::getAccuracyRadiusColor, "nativeGetAccuracyRadiusColor"),
+        METHOD(&LocationIndicatorLayer::getAccuracyRadiusBorderColorTransition,
+               "nativeGetAccuracyRadiusBorderColorTransition"),
+        METHOD(&LocationIndicatorLayer::setAccuracyRadiusBorderColorTransition,
+               "nativeSetAccuracyRadiusBorderColorTransition"),
+        METHOD(&LocationIndicatorLayer::getAccuracyRadiusBorderColor, "nativeGetAccuracyRadiusBorderColor"));
+}
 
 } // namespace android
 } // namespace mbgl

platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/location_indicator_layer.hpp

@@ -68,7 +68,8 @@ public:
 
 }; // class LocationIndicatorLayer
 
-class LocationIndicatorJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::LocationIndicatorLayerFactory {
+class LocationIndicatorJavaLayerPeerFactory final : public JavaLayerPeerFactory,
+                                                    public mbgl::LocationIndicatorLayerFactory {
 public:
     ~LocationIndicatorJavaLayerPeerFactory() override;
 
@@ -80,7 +81,7 @@ public:
 
     LayerFactory* getLayerFactory() final { return this; }
 
-};  // class LocationIndicatorJavaLayerPeerFactory
+}; // class LocationIndicatorJavaLayerPeerFactory
 
 } // namespace android
 } // namespace mbgl

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

@@ -12,211 +12,212 @@
 namespace mbgl {
 namespace android {
 
-    inline mbgl::style::RasterLayer& toRasterLayer(mbgl::style::Layer& layer) {
-        return static_cast<mbgl::style::RasterLayer&>(layer);
-    }
+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 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 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)) {
-    }
+/**
+ * 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;
+RasterLayer::~RasterLayer() = default;
 
-    // Property getters
+// 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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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<>> 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));
-    }
+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);
-    }
+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::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()));
-    }
+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::~RasterJavaLayerPeerFactory() = default;
 
-    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
 
-    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, 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()))));
+}
 
-    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);
 
-    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)
 
-        #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"));
-    }
+    // 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

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

@@ -56,7 +56,7 @@ public:
 
 }; // class RasterLayer
 
-class RasterJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::RasterLayerFactory {
+class RasterJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::RasterLayerFactory {
 public:
     ~RasterJavaLayerPeerFactory() override;
 
@@ -68,7 +68,7 @@ public:
 
     LayerFactory* getLayerFactory() final { return this; }
 
-};  // class RasterJavaLayerPeerFactory
+}; // class RasterJavaLayerPeerFactory
 
 } // namespace android
 } // namespace mbgl

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

@@ -162,7 +162,7 @@ public:
 
 }; // class SymbolLayer
 
-class SymbolJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::SymbolLayerFactory {
+class SymbolJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::SymbolLayerFactory {
 public:
     ~SymbolJavaLayerPeerFactory() override;
 
@@ -174,7 +174,7 @@ public:
 
     LayerFactory* getLayerFactory() final { return this; }
 
-};  // class SymbolJavaLayerPeerFactory
+}; // class SymbolJavaLayerPeerFactory
 
 } // namespace android
 } // namespace mbgl

platform/android/MapboxGLAndroidSDK/src/cpp/style/light.cpp

@@ -7,8 +7,8 @@ namespace mbgl {
 namespace android {
 
 Light::Light(mbgl::Map& coreMap, mbgl::style::Light& coreLight)
-    : light(coreLight) , map(&coreMap) {
-}
+    : light(coreLight),
+      map(&coreMap) {}
 
 static Light* initializeLightPeer(mbgl::Map& map, mbgl::style::Light& coreLight) {
     return new Light(map, coreLight);
@@ -58,16 +58,16 @@ jni::Local<jni::Object<Position>> Light::getPosition(jni::JNIEnv& env) {
 }
 
 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));
+    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);
+    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) {
@@ -77,22 +77,22 @@ void Light::setColor(jni::JNIEnv& env, const jni::String& property) {
     }
 }
 
-jni::Local<jni::String> Light::getColor(jni::JNIEnv &env) {
+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));
+    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);
+    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) {
@@ -104,16 +104,16 @@ jni::jfloat Light::getIntensity(jni::JNIEnv&) {
 }
 
 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));
+    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);
+    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) {
@@ -122,22 +122,24 @@ void Light::registerNative(jni::JNIEnv& 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"));
+    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
+} // namespace mbgl

platform/android/MapboxGLAndroidSDK/src/cpp/style/light.hpp

@@ -16,7 +16,6 @@ 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&);
@@ -42,7 +41,6 @@ public:
     jni::Local<jni::Object<Light>> createJavaPeer(jni::JNIEnv&);
 
 protected:
-
     // Raw reference to the light
     mbgl::style::Light& light;
 

platform/android/MapboxGLAndroidSDK/src/cpp/style/position.cpp

@@ -3,9 +3,12 @@
 namespace mbgl {
 namespace android {
 
-jni::Local<jni::Object<Position>> Position::fromPosition(jni::JNIEnv& env, jfloat radialCoordinate, jfloat azimuthalAngle, jfloat polarAngle) {
+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");
+    static auto method = javaClass.GetStaticMethod<jni::Object<Position>(jfloat, jfloat, jfloat)>(env, "fromPosition");
     return javaClass.Call(env, method, radialCoordinate, azimuthalAngle, polarAngle);
 }
 

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

@@ -18,192 +18,196 @@
 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;
-        std::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;
+// 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;
+    std::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;
     }
 
-    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)))) {
+    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;
     }
 
-    CustomGeometrySource::CustomGeometrySource(jni::JNIEnv& env,
-                                               mbgl::style::Source& coreSource,
-                                               AndroidRendererFrontend* frontend)
-        : Source(env, coreSource, createJavaPeer(env), frontend) {}
+    auto peer = jni::Cast(*_env, javaClass, javaPeer);
+    peer.Call(*_env, cancelTile, (int)tileID.z, (int)tileID.x, (int)tileID.y);
+};
 
-    CustomGeometrySource::~CustomGeometrySource() {
+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");
+
+    if (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::fetchTile (const mbgl::CanonicalTileID& tileID) {
-        android::UniqueEnv _env = android::AttachEnv();
+void CustomGeometrySource::registerNative(jni::JNIEnv& env) {
+    // Lookup the class
+    static auto& javaClass = jni::Class<CustomGeometrySource>::Singleton(env);
 
-        static auto& javaClass = jni::Class<CustomGeometrySource>::Singleton(*_env);
-        static auto fetchTile = javaClass.GetMethod<void (jni::jint, jni::jint, jni::jint)>(*_env, "fetchTile");
+#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
-        // 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");
-
-        if(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")
-        );
-    }
+    // 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

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

@@ -34,13 +34,14 @@ public:
     void releaseThreads();
 
 private:
-    void setTileData(jni::JNIEnv& env, jni::jint z, jni::jint x, jni::jint y, const jni::Object<geojson::FeatureCollection>& jf);
+    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<>>& );
+                                                                              const jni::Array<jni::Object<>>&);
 
     jni::Local<jni::Object<Source>> createJavaPeer(jni::JNIEnv&);
 

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

@@ -19,24 +19,26 @@
 
 #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,
+// 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.
+// 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;
-    std::optional<style::GeoJSONOptions> result = convert<style::GeoJSONOptions>(mbgl::android::Value(env, options), error);
+    std::optional<style::GeoJSONOptions> result = convert<style::GeoJSONOptions>(mbgl::android::Value(env, options),
+                                                                                 error);
     if (!result) {
         throw std::logic_error(error.message);
     }
@@ -67,193 +69,200 @@ void GeoJSONSource::setGeoJSONString(jni::JNIEnv& env, const jni::String& jStrin
     setAsync(converterFn);
 }
 
-    void GeoJSONSource::setFeatureCollection(jni::JNIEnv& env, const jni::Object<geojson::FeatureCollection>& jFeatures) {
-        setCollectionAsync(env, jFeatures);
+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) {
+    std::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);
+}
 
-    void GeoJSONSource::setFeature(jni::JNIEnv& env, const jni::Object<geojson::Feature>& jFeature) {
-        setCollectionAsync(env, jFeature);
-    }
+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;
 
-    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) {
-        std::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) });
+    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 Feature::convert(env, features);
     }
+    return jni::Array<jni::Object<Feature>>::New(env, 0);
+}
 
-    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;
+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 auto featureExtension = rendererFrontend->queryFeatureExtensions(source.getID(), _feature, "supercluster", "children", {});
-            if (featureExtension.is<mbgl::FeatureCollection>()) {
-                return Feature::convert(env, featureExtension.get<mbgl::FeatureCollection>());
+    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 jni::Array<jni::Object<Feature>>::New(env, 0);
     }
+    return 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;
+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));
+}
 
-        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);;
-    }
+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));
 
-    jint GeoJSONSource::getClusterExpansionZoom(jni::JNIEnv& env, const jni::Object<geojson::Feature>& feature) {
-        using namespace mbgl::android::conversion;
-        using namespace mbgl::android::geojson;
+    Update::Converter converterFn = [this, object](ActorRef<GeoJSONDataCallback> _callback) {
+        converter->self().invoke(&FeatureConverter::convertObject<JNIType>, object, _callback);
+    };
 
-        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>();
+    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();
                 }
-            }
-        }
-        return 0;
+            }));
+
+    // If another update is running, wait
+    if (update) {
+        return;
     }
 
-    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));
+    // 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;
+    std::optional<GeoJSON> converted = parseGeoJSON(*json, error);
+    if (!converted) {
+        mbgl::Log::Error(mbgl::Event::JNI, "Error setting geo json: " + error.message);
+        return;
     }
 
-    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));
+    callback.invoke(&GeoJSONDataCallback::operator(), style::GeoJSONData::create(*converted, options));
+}
 
-        Update::Converter converterFn = [this, object](ActorRef<GeoJSONDataCallback> _callback) {
-            converter->self().invoke(&FeatureConverter::convertObject<JNIType>, object, _callback);
-        };
+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;
 
-        setAsync(converterFn);
-    }
+    android::UniqueEnv _env = android::AttachEnv();
+    // Convert the jni object
+    auto geometry = JNIType::convert(*_env, *jObject);
+    callback.invoke(&GeoJSONDataCallback::operator(), style::GeoJSONData::create(geometry, options));
+}
 
-    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;
-        std::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)) {}
+Update::Update(Converter _converterFn, std::unique_ptr<Actor<GeoJSONDataCallback>> _callback)
+    : converterFn(std::move(_converterFn)),
+      callback(std::move(_callback)) {}
 
 } // namespace android
 } // namespace mbgl

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

@@ -15,7 +15,8 @@ using GeoJSONDataCallback = std::function<void(std::shared_ptr<style::GeoJSONDat
 
 class FeatureConverter {
 public:
-    explicit FeatureConverter(Immutable<style::GeoJSONOptions> options_) : options(std::move(options_)) {}
+    explicit FeatureConverter(Immutable<style::GeoJSONOptions> options_)
+        : options(std::move(options_)) {}
     void convertJson(std::shared_ptr<std::string>, ActorRef<GeoJSONDataCallback>);
 
     template <class JNIType>
@@ -54,10 +55,14 @@ private:
     void setURL(jni::JNIEnv&, const jni::String&);
 
     jni::Local<jni::Array<jni::Object<geojson::Feature>>> querySourceFeatures(jni::JNIEnv&,
-                                                                  const jni::Array<jni::Object<>>&);
+                                                                              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);
+    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&);

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

@@ -15,62 +15,60 @@
 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,
+                         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(jni::JNIEnv& env, mbgl::style::Source& coreSource, AndroidRendererFrontend* frontend)
+    : Source(env, coreSource, createJavaPeer(env), frontend) {}
 
-    ImageSource::~ImageSource() = default;
+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));
-    }
+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) {
-        std::optional<std::string> url = source.as<mbgl::style::ImageSource>()->ImageSource::getURL();
-        return url ? jni::Make<jni::String>(env, *url) : jni::Local<jni::String>();
-    }
+jni::Local<jni::String> ImageSource::getURL(jni::JNIEnv& env) {
+    std::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::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));
-    }
+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));
-    }
+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);
+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)
+#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")
-        );
-    }
+    // 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

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

@@ -12,50 +12,46 @@
 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,
+                                 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(jni::JNIEnv& env, mbgl::style::Source& coreSource, AndroidRendererFrontend* frontend)
+    : Source(env, coreSource, createJavaPeer(env), frontend) {}
 
-    RasterDEMSource::~RasterDEMSource() = default;
+RasterDEMSource::~RasterDEMSource() = default;
 
-    jni::Local<jni::String> RasterDEMSource::getURL(jni::JNIEnv& env) {
-        std::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::String> RasterDEMSource::getURL(jni::JNIEnv& env) {
+    std::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));
-    }
+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);
+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)
+#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")
-        );
-    }
+    // 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

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

@@ -11,48 +11,46 @@
 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,
+                           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(jni::JNIEnv& env, mbgl::style::Source& coreSource, AndroidRendererFrontend* frontend)
+    : Source(env, coreSource, createJavaPeer(env), frontend) {}
 
-    RasterSource::~RasterSource() = default;
+RasterSource::~RasterSource() = default;
 
-    jni::Local<jni::String> RasterSource::getURL(jni::JNIEnv& env) {
-        std::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::String> RasterSource::getURL(jni::JNIEnv& env) {
+    std::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));
-    }
+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);
+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)
+#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")
-        );
-    }
+    // 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

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

@@ -50,205 +50,208 @@ static std::unique_ptr<Source> createSourcePeer(jni::JNIEnv& env,
     }
 }
 
-    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,
+                                                     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;
+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& 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(jni::JNIEnv&, std::unique_ptr<mbgl::style::Source> coreSource)
+    : ownedSource(std::move(coreSource)),
+      source(*ownedSource) {}
+
+Source::~Source() {
+    if (ownedSource) {
+        ownedSource.reset();
+        ownedSource.release();
     }
-
-    Source::~Source() {
-        if (ownedSource) {
-            ownedSource.reset();
-            ownedSource.release();
-        }
-        // 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(std::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(std::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;
-    }
-
-    jni::Local<jni::Boolean> Source::isVolatile(jni::JNIEnv& env) {
-        return jni::Box(env, jni::jboolean(source.isVolatile()));
-    }
-
-    void Source::setVolatile(JNIEnv& env, jni::Boolean& value) {
-        source.setVolatile(jni::Unbox(env, value));
-    }
-
-    void Source::setMinimumTileUpdateInterval(JNIEnv& env, jni::Long& interval) {
-        source.setMinimumTileUpdateInterval(Milliseconds(jni::Unbox(env, interval)));
-    }
-
-    jni::Local<jni::Long> Source::getMinimumTileUpdateInterval(JNIEnv& env) {
-        return jni::Box(env, jni::jlong(source.getMinimumTileUpdateInterval().count() / 1000000));
-    }
-
-    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);
+    // 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();
+    }
+}
 
-        rendererFrontend = nullptr;
+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(std::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(std::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");
     }
 
-    void Source::registerNative(jni::JNIEnv& env) {
-        // Lookup the class
-        static auto& javaClass = jni::Class<Source>::Singleton(env);
+    // Add source to style and release ownership
+    style.addSource(std::move(ownedSource));
 
-        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+    // Add peer to core source
+    source.peer = std::unique_ptr<Source>(this);
 
-        // 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"),
-            METHOD(&Source::isVolatile, "nativeIsVolatile"),
-            METHOD(&Source::setVolatile, "nativeSetVolatile"),
-            METHOD(&Source::setMinimumTileUpdateInterval, "nativeSetMinimumTileUpdateInterval"),
-            METHOD(&Source::getMinimumTileUpdateInterval, "nativeGetMinimumTileUpdateInterval"));
+    // Add strong reference to java source
+    javaPeer = jni::NewGlobal(env, obj);
+}
 
-
-        // Register subclasses
-        GeoJSONSource::registerNative(env);
-        ImageSource::registerNative(env);
-        RasterSource::registerNative(env);
-        UnknownSource::registerNative(env);
-        VectorSource::registerNative(env);
-        CustomGeometrySource::registerNative(env);
-        RasterDEMSource::registerNative(env);
+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;
+}
+
+jni::Local<jni::Boolean> Source::isVolatile(jni::JNIEnv& env) {
+    return jni::Box(env, jni::jboolean(source.isVolatile()));
+}
+
+void Source::setVolatile(JNIEnv& env, jni::Boolean& value) {
+    source.setVolatile(jni::Unbox(env, value));
+}
+
+void Source::setMinimumTileUpdateInterval(JNIEnv& env, jni::Long& interval) {
+    source.setMinimumTileUpdateInterval(Milliseconds(jni::Unbox(env, interval)));
+}
+
+jni::Local<jni::Long> Source::getMinimumTileUpdateInterval(JNIEnv& env) {
+    return jni::Box(env, jni::jlong(source.getMinimumTileUpdateInterval().count() / 1000000));
+}
+
+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.reset();
+
+    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"),
+        METHOD(&Source::isVolatile, "nativeIsVolatile"),
+        METHOD(&Source::setVolatile, "nativeSetVolatile"),
+        METHOD(&Source::setMinimumTileUpdateInterval, "nativeSetMinimumTileUpdateInterval"),
+        METHOD(&Source::getMinimumTileUpdateInterval, "nativeGetMinimumTileUpdateInterval"));
+
+    // 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

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

@@ -14,7 +14,6 @@ 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&);
@@ -28,7 +27,8 @@ public:
     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.
+     * 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>);
 
@@ -54,11 +54,11 @@ public:
 
     void addToStyle(JNIEnv& env, const jni::Object<Source>& obj, mbgl::style::Style& style);
 
-    jni::Local<jni::Boolean > isVolatile(JNIEnv&);
+    jni::Local<jni::Boolean> isVolatile(JNIEnv&);
 
     void setVolatile(JNIEnv&, jni::Boolean&);
 
-    void setMinimumTileUpdateInterval(JNIEnv&, jni::Long &);
+    void setMinimumTileUpdateInterval(JNIEnv&, jni::Long&);
 
     jni::Local<jni::Long> getMinimumTileUpdateInterval(JNIEnv&);
 
@@ -73,7 +73,7 @@ protected:
     jni::Global<jni::Object<Source>> javaPeer;
 
     // RendererFrontend pointer is valid only when added to the map.
-    AndroidRendererFrontend* rendererFrontend { nullptr };
+    AndroidRendererFrontend* rendererFrontend{nullptr};
 };
 
 } // namespace android

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

@@ -2,10 +2,10 @@
 
 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");
-    }
+// 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
 
@@ -21,20 +21,15 @@ jni::Local<jni::Object<Source>> UnknownSource::createJavaPeer(jni::JNIEnv& 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);
+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)
+#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
-        // Register the peer
-        jni::RegisterNativePeer<UnknownSource>(
-            env, javaClass, "nativePtr",
-            init,
-            "initialize",
-            "finalize"
-        );
-    }
+    // Register the peer
+    jni::RegisterNativePeer<UnknownSource>(env, javaClass, "nativePtr", init, "initialize", "finalize");
+}
 
 } // namespace android
 } // namespace mbgl

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

@@ -20,62 +20,56 @@
 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, 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) {
+    std::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);
+}
 
-    VectorSource::VectorSource(jni::JNIEnv& env, mbgl::style::Source& coreSource, AndroidRendererFrontend* frontend)
-        : Source(env, coreSource, createJavaPeer(env), frontend) {}
+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));
+}
 
-    VectorSource::~VectorSource() = default;
+void VectorSource::registerNative(jni::JNIEnv& env) {
+    // Lookup the class
+    static auto& javaClass = jni::Class<VectorSource>::Singleton(env);
 
-    jni::Local<jni::String> VectorSource::getURL(jni::JNIEnv& env) {
-        std::optional<std::string> url = source.as<mbgl::style::VectorSource>()->VectorSource::getURL();
-        return url ? jni::Make<jni::String>(env, *url) : jni::Local<jni::String>();
-    }
+#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
-    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")
-        );
-    }
+    // 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

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

@@ -20,8 +20,9 @@ public:
     ~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::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&);
 

platform/android/MapboxGLAndroidSDK/src/cpp/style/transition_options.cpp

@@ -3,9 +3,11 @@
 namespace mbgl {
 namespace android {
 
-jni::Local<jni::Object<TransitionOptions>> TransitionOptions::fromTransitionOptions(jni::JNIEnv& env, jlong duration, jlong delay, jboolean enablePlacementTransitions) {
+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");
+    static auto method = javaClass.GetStaticMethod<jni::Object<TransitionOptions>(jlong, jlong, jboolean)>(
+        env, "fromTransitionOptions");
     return javaClass.Call(env, method, duration, delay, enablePlacementTransitions);
 }
 
@@ -21,9 +23,10 @@ long TransitionOptions::getDelay(jni::JNIEnv& env, const jni::Object<TransitionO
     return transitionOptions.Get(env, field);
 }
 
-bool TransitionOptions::isEnablePlacementTransitions(jni::JNIEnv& env, const jni::Object<mbgl::android::TransitionOptions>& transitionOptions) {
+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");
+    static auto field = javaClass.GetField<jboolean>(env, "enablePlacementTransitions");
     return transitionOptions.Get(env, field);
 }
 

platform/android/MapboxGLAndroidSDK/src/cpp/style/transition_options.hpp

@@ -11,7 +11,10 @@ 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 jni::Local<jni::Object<TransitionOptions>> fromTransitionOptions(jni::JNIEnv&,
+                                                                            jlong duration,
+                                                                            jlong delay,
+                                                                            jboolean enablePlacementTransitions);
 
     static long getDuration(jni::JNIEnv&, const jni::Object<TransitionOptions>&);
 

platform/android/MapboxGLAndroidSDK/src/cpp/style/value.cpp

@@ -4,80 +4,80 @@
 
 namespace mbgl {
 namespace android {
-    // Instance
+// Instance
 
-    Value::Value(jni::JNIEnv& _env, jni::Local<jni::Object<>> _value)
-        : env(_env),
-          value(std::move(_value)) {}
+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)) {}
+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)));
-    }
-}
+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)));
+}
+} // namespace android
+} // namespace mbgl

platform/android/MapboxGLAndroidSDK/src/cpp/style/value.hpp

@@ -12,10 +12,10 @@ public:
     Value(jni::JNIEnv&, jni::Local<jni::Object<>>);
     Value(jni::JNIEnv&, const jni::Object<>&);
 
-    Value(Value&&)                 = default;
-    Value& operator=(Value&&)      = delete;
+    Value(Value&&) = default;
+    Value& operator=(Value&&) = delete;
 
-    Value(const Value&)            = delete;
+    Value(const Value&) = delete;
     Value& operator=(const Value&) = delete;
 
     bool isNull() const;
@@ -33,11 +33,11 @@ public:
     Value get(const char* key) const;
     Value keyArray() const;
     int getLength() const;
-    Value get(const int index ) const;
+    Value get(const int index) const;
 
     jni::JNIEnv& env;
     jni::Local<jni::Object<>> value;
 };
 
-}
-}
+} // namespace android
+} // namespace mbgl