[android] add bindings for LocationIndicatorLayerupstream/lp-location-layer-bindings

19 files changed, 385 insertions, 90 deletions

diff --git a/include/mbgl/style/layers/layer.hpp.ejs b/include/mbgl/style/layers/layer.hpp.ejs
index 42cc12959f..198a3e5a4e 100644
--- a/include/mbgl/style/layers/layer.hpp.ejs
+++ b/include/mbgl/style/layers/layer.hpp.ejs
@@ -29,7 +29,7 @@ class TransitionOptions;
 
 class <%- camelize(type) %>Layer : public Layer {
 public:
-<% if ((type === 'background') || (type === 'location-component')) { -%>
+<% if (type === 'background' || type === 'location-component') { -%>
     <%- camelize(type) %>Layer(const std::string& layerID);
 <% } else { -%>
     <%- camelize(type) %>Layer(const std::string& layerID, const std::string& sourceID);
diff --git a/platform/android/android.cmake b/platform/android/android.cmake
index 89f3860dfb..0927c22605 100644
--- a/platform/android/android.cmake
+++ b/platform/android/android.cmake
@@ -179,6 +179,8 @@ target_sources(
         ${PROJECT_SOURCE_DIR}/platform/android/src/style/layers/raster_layer.hpp
         ${PROJECT_SOURCE_DIR}/platform/android/src/style/layers/symbol_layer.cpp
         ${PROJECT_SOURCE_DIR}/platform/android/src/style/layers/symbol_layer.hpp
+        ${PROJECT_SOURCE_DIR}/platform/android/src/style/layers/location_component_layer.cpp
+        ${PROJECT_SOURCE_DIR}/platform/android/src/style/layers/location_component_layer.hpp
         ${PROJECT_SOURCE_DIR}/platform/android/src/style/light.cpp
         ${PROJECT_SOURCE_DIR}/platform/android/src/style/light.hpp
         ${PROJECT_SOURCE_DIR}/platform/android/src/style/position.cpp
diff --git a/platform/android/src/conversion/constant.cpp b/platform/android/src/conversion/constant.cpp
index 46a91026df..53c63e1e67 100644
--- a/platform/android/src/conversion/constant.cpp
+++ b/platform/android/src/conversion/constant.cpp
@@ -52,6 +52,16 @@ Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vect
     return result;
 }
 
+Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vector<double>>::operator()(jni::JNIEnv& env, const std::vector<double>& value) const {
+    auto result = jni::Array<jni::Double>::New(env, value.size());
+
+    for (std::size_t i = 0; i < value.size(); i++) {
+        result.Set(env, i, jni::Box(env, value.at(i)));
+    }
+
+    return result;
+}
+
 Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, style::expression::Image>::operator()(
     jni::JNIEnv& env, const style::expression::Image& value) const {
     return jni::Make<jni::String>(env, value.id());
diff --git a/platform/android/src/conversion/constant.hpp b/platform/android/src/conversion/constant.hpp
index a9239fe845..b291f29f04 100644
--- a/platform/android/src/conversion/constant.hpp
+++ b/platform/android/src/conversion/constant.hpp
@@ -72,6 +72,17 @@ struct Converter<jni::Local<jni::Object<>>, std::array<float, N>> {
     }
 };
 
+template <std::size_t N>
+struct Converter<jni::Local<jni::Object<>>, std::array<double, N>> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const std::array<double, N>& value) const {
+        std::vector<double> v;
+        for (const double& id : value) {
+            v.push_back(id);
+        }
+        return convert<jni::Local<jni::Object<>>, std::vector<double>>(env, v);
+    }
+};
+
 template <>
 struct Converter<jni::Local<jni::Object<>>, std::vector<std::string>> {
     Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const std::vector<std::string>& value) const;
@@ -82,6 +93,11 @@ struct Converter<jni::Local<jni::Object<>>, std::vector<float>> {
     Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const std::vector<float>& value) const;
 };
 
+template <>
+struct Converter<jni::Local<jni::Object<>>, std::vector<double>> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const std::vector<double>& value) const;
+};
+
 template <class T>
 struct Converter<jni::Local<jni::Object<>>, T, typename std::enable_if_t<std::is_enum<T>::value>> {
     Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const T& value) const {
diff --git a/platform/android/src/style/layers/background_layer.cpp b/platform/android/src/style/layers/background_layer.cpp
index 3eae30677f..d0084dc2de 100644
--- a/platform/android/src/style/layers/background_layer.cpp
+++ b/platform/android/src/style/layers/background_layer.cpp
@@ -26,13 +26,16 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    BackgroundLayer::BackgroundLayer(mbgl::style::BackgroundLayer& coreLayer) : Layer(coreLayer) {}
+    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)) {}
+        : Layer(std::move(coreLayer)) {
+    }
 
     BackgroundLayer::~BackgroundLayer() = default;
 
@@ -105,18 +108,14 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> BackgroundJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
-                                                                                       mbgl::style::Layer& 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) {
+    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()))));
+        return createJavaPeer(env, new BackgroundLayer(std::unique_ptr<mbgl::style::BackgroundLayer>(static_cast<mbgl::style::BackgroundLayer*>(layer.release()))));
     }
 
     void BackgroundJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
diff --git a/platform/android/src/style/layers/circle_layer.cpp b/platform/android/src/style/layers/circle_layer.cpp
index a7fae5e233..54267e819a 100644
--- a/platform/android/src/style/layers/circle_layer.cpp
+++ b/platform/android/src/style/layers/circle_layer.cpp
@@ -26,12 +26,16 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    CircleLayer::CircleLayer(mbgl::style::CircleLayer& coreLayer) : Layer(coreLayer) {}
+    CircleLayer::CircleLayer(mbgl::style::CircleLayer& coreLayer)
+        : Layer(coreLayer) {
+    }
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    CircleLayer::CircleLayer(std::unique_ptr<mbgl::style::CircleLayer> coreLayer) : Layer(std::move(coreLayer)) {}
+    CircleLayer::CircleLayer(std::unique_ptr<mbgl::style::CircleLayer> coreLayer)
+        : Layer(std::move(coreLayer)) {
+    }
 
     CircleLayer::~CircleLayer() = default;
 
@@ -209,18 +213,14 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> CircleJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
-                                                                                   mbgl::style::Layer& 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) {
+    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()))));
+        return createJavaPeer(env, new CircleLayer(std::unique_ptr<mbgl::style::CircleLayer>(static_cast<mbgl::style::CircleLayer*>(layer.release()))));
     }
 
     void CircleJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
diff --git a/platform/android/src/style/layers/fill_extrusion_layer.cpp b/platform/android/src/style/layers/fill_extrusion_layer.cpp
index 55c3d20282..9b7c66a0a5 100644
--- a/platform/android/src/style/layers/fill_extrusion_layer.cpp
+++ b/platform/android/src/style/layers/fill_extrusion_layer.cpp
@@ -26,13 +26,16 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    FillExtrusionLayer::FillExtrusionLayer(mbgl::style::FillExtrusionLayer& coreLayer) : Layer(coreLayer) {}
+    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)) {}
+        : Layer(std::move(coreLayer)) {
+    }
 
     FillExtrusionLayer::~FillExtrusionLayer() = default;
 
@@ -169,18 +172,14 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> FillExtrusionJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
-                                                                                          mbgl::style::Layer& 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) {
+    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()))));
+        return createJavaPeer(env, new FillExtrusionLayer(std::unique_ptr<mbgl::style::FillExtrusionLayer>(static_cast<mbgl::style::FillExtrusionLayer*>(layer.release()))));
     }
 
     void FillExtrusionJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
@@ -203,10 +202,8 @@ namespace android {
             METHOD(&FillExtrusionLayer::getFillExtrusionColorTransition, "nativeGetFillExtrusionColorTransition"),
             METHOD(&FillExtrusionLayer::setFillExtrusionColorTransition, "nativeSetFillExtrusionColorTransition"),
             METHOD(&FillExtrusionLayer::getFillExtrusionColor, "nativeGetFillExtrusionColor"),
-            METHOD(&FillExtrusionLayer::getFillExtrusionTranslateTransition,
-                   "nativeGetFillExtrusionTranslateTransition"),
-            METHOD(&FillExtrusionLayer::setFillExtrusionTranslateTransition,
-                   "nativeSetFillExtrusionTranslateTransition"),
+            METHOD(&FillExtrusionLayer::getFillExtrusionTranslateTransition, "nativeGetFillExtrusionTranslateTransition"),
+            METHOD(&FillExtrusionLayer::setFillExtrusionTranslateTransition, "nativeSetFillExtrusionTranslateTransition"),
             METHOD(&FillExtrusionLayer::getFillExtrusionTranslate, "nativeGetFillExtrusionTranslate"),
             METHOD(&FillExtrusionLayer::getFillExtrusionTranslateAnchor, "nativeGetFillExtrusionTranslateAnchor"),
             METHOD(&FillExtrusionLayer::getFillExtrusionPatternTransition, "nativeGetFillExtrusionPatternTransition"),
diff --git a/platform/android/src/style/layers/fill_layer.cpp b/platform/android/src/style/layers/fill_layer.cpp
index 6a646fdc7d..ba6ed21791 100644
--- a/platform/android/src/style/layers/fill_layer.cpp
+++ b/platform/android/src/style/layers/fill_layer.cpp
@@ -26,12 +26,16 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    FillLayer::FillLayer(mbgl::style::FillLayer& coreLayer) : Layer(coreLayer) {}
+    FillLayer::FillLayer(mbgl::style::FillLayer& coreLayer)
+        : Layer(coreLayer) {
+    }
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    FillLayer::FillLayer(std::unique_ptr<mbgl::style::FillLayer> coreLayer) : Layer(std::move(coreLayer)) {}
+    FillLayer::FillLayer(std::unique_ptr<mbgl::style::FillLayer> coreLayer)
+        : Layer(std::move(coreLayer)) {
+    }
 
     FillLayer::~FillLayer() = default;
 
@@ -155,18 +159,14 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> FillJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
-                                                                                 mbgl::style::Layer& 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) {
+    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()))));
+        return createJavaPeer(env, new FillLayer(std::unique_ptr<mbgl::style::FillLayer>(static_cast<mbgl::style::FillLayer*>(layer.release()))));
     }
 
     void FillJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
diff --git a/platform/android/src/style/layers/heatmap_layer.cpp b/platform/android/src/style/layers/heatmap_layer.cpp
index dad3d25e6c..dfb8bbb4b3 100644
--- a/platform/android/src/style/layers/heatmap_layer.cpp
+++ b/platform/android/src/style/layers/heatmap_layer.cpp
@@ -26,12 +26,16 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    HeatmapLayer::HeatmapLayer(mbgl::style::HeatmapLayer& coreLayer) : Layer(coreLayer) {}
+    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(std::unique_ptr<mbgl::style::HeatmapLayer> coreLayer)
+        : Layer(std::move(coreLayer)) {
+    }
 
     HeatmapLayer::~HeatmapLayer() = default;
 
@@ -118,18 +122,14 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> HeatmapJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
-                                                                                    mbgl::style::Layer& layer) {
+    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) {
+    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()))));
+        return createJavaPeer(env, new HeatmapLayer(std::unique_ptr<mbgl::style::HeatmapLayer>(static_cast<mbgl::style::HeatmapLayer*>(layer.release()))));
     }
 
     void HeatmapJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
diff --git a/platform/android/src/style/layers/hillshade_layer.cpp b/platform/android/src/style/layers/hillshade_layer.cpp
index 1f5fe1912f..3c72b503b7 100644
--- a/platform/android/src/style/layers/hillshade_layer.cpp
+++ b/platform/android/src/style/layers/hillshade_layer.cpp
@@ -26,13 +26,16 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    HillshadeLayer::HillshadeLayer(mbgl::style::HillshadeLayer& coreLayer) : Layer(coreLayer) {}
+    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)) {}
+        : Layer(std::move(coreLayer)) {
+    }
 
     HillshadeLayer::~HillshadeLayer() = default;
 
@@ -133,18 +136,14 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> HillshadeJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
-                                                                                      mbgl::style::Layer& 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) {
+    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()))));
+        return createJavaPeer(env, new HillshadeLayer(std::unique_ptr<mbgl::style::HillshadeLayer>(static_cast<mbgl::style::HillshadeLayer*>(layer.release()))));
     }
 
     void HillshadeJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
diff --git a/platform/android/src/style/layers/layer.cpp.ejs b/platform/android/src/style/layers/layer.cpp.ejs
index 5d241e9a3b..6b67b5919d 100644
--- a/platform/android/src/style/layers/layer.cpp.ejs
+++ b/platform/android/src/style/layers/layer.cpp.ejs
@@ -20,7 +20,7 @@ namespace android {
         return static_cast<mbgl::style::<%- camelize(type) %>Layer&>(layer);
     }
 
-<% if (type === 'background') { -%>
+<% if (type === 'background' || type === 'location-component') { -%>
     /**
      * Creates an owning peer object (for layers not attached to the map) from the JVM side
      */
@@ -121,7 +121,7 @@ namespace android {
             env,
             javaClass,
             "nativePtr",
-<% if (type === 'background') { -%>
+<% if (type === 'background' || type === 'location-component') { -%>
             jni::MakePeer<<%- camelize(type) %>Layer, jni::String&>,
 <% } else { -%>
             jni::MakePeer<<%- camelize(type) %>Layer, jni::String&, jni::String&>,
diff --git a/platform/android/src/style/layers/layer.hpp.ejs b/platform/android/src/style/layers/layer.hpp.ejs
index eb8db0620d..c6fb183e66 100644
--- a/platform/android/src/style/layers/layer.hpp.ejs
+++ b/platform/android/src/style/layers/layer.hpp.ejs
@@ -20,7 +20,7 @@ public:
     using SuperTag = Layer;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/<%- camelize(type) %>Layer"; };
 
-<% if (type === 'background') { -%>
+<% if (type === 'background' || type === 'location-component') { -%>
     <%- camelize(type) %>Layer(jni::JNIEnv&, jni::String&);
 <% } else { -%>
     <%- camelize(type) %>Layer(jni::JNIEnv&, jni::String&, jni::String&);
diff --git a/platform/android/src/style/layers/layer_manager.cpp b/platform/android/src/style/layers/layer_manager.cpp
index 2d4172a235..89011bd3ea 100644
--- a/platform/android/src/style/layers/layer_manager.cpp
+++ b/platform/android/src/style/layers/layer_manager.cpp
@@ -17,6 +17,7 @@
 #include "raster_layer.hpp"
 #include "symbol_layer.hpp"
 #include "fill_extrusion_layer.hpp"
+#include "location_component_layer.hpp"
 
 namespace mbgl {
 
@@ -73,6 +74,9 @@ LayerManagerAndroid::LayerManagerAndroid() {
 #elif !defined(MBGL_LAYER_CUSTOM_DISABLE_ALL)
     addLayerType(std::make_unique<CustomJavaLayerPeerFactory>());
 #endif
+#if !defined(MBGL_LAYER_LOCATION_COMPONENT_DISABLE_ALL)
+    addLayerType(std::make_unique<LocationComponentJavaLayerPeerFactory>());
+#endif
 }
 
 LayerManagerAndroid::~LayerManagerAndroid() = default;
diff --git a/platform/android/src/style/layers/line_layer.cpp b/platform/android/src/style/layers/line_layer.cpp
index 89c6cb5323..bf3a403b66 100644
--- a/platform/android/src/style/layers/line_layer.cpp
+++ b/platform/android/src/style/layers/line_layer.cpp
@@ -26,12 +26,16 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    LineLayer::LineLayer(mbgl::style::LineLayer& coreLayer) : Layer(coreLayer) {}
+    LineLayer::LineLayer(mbgl::style::LineLayer& coreLayer)
+        : Layer(coreLayer) {
+    }
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    LineLayer::LineLayer(std::unique_ptr<mbgl::style::LineLayer> coreLayer) : Layer(std::move(coreLayer)) {}
+    LineLayer::LineLayer(std::unique_ptr<mbgl::style::LineLayer> coreLayer)
+        : Layer(std::move(coreLayer)) {
+    }
 
     LineLayer::~LineLayer() = default;
 
@@ -247,18 +251,14 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> LineJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
-                                                                                 mbgl::style::Layer& 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) {
+    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()))));
+        return createJavaPeer(env, new LineLayer(std::unique_ptr<mbgl::style::LineLayer>(static_cast<mbgl::style::LineLayer*>(layer.release()))));
     }
 
     void LineJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
diff --git a/platform/android/src/style/layers/location_component_layer.cpp b/platform/android/src/style/layers/location_component_layer.cpp
new file mode 100644
index 0000000000..57433b930b
--- /dev/null
+++ b/platform/android/src/style/layers/location_component_layer.cpp
@@ -0,0 +1,192 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include "location_component_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+#include "../conversion/transition_options.hpp"
+
+#include <mbgl/style/layer_impl.hpp>
+
+namespace mbgl {
+namespace android {
+
+    inline mbgl::style::LocationComponentLayer& toLocationComponentLayer(mbgl::style::Layer& layer) {
+        return static_cast<mbgl::style::LocationComponentLayer&>(layer);
+    }
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map) from the JVM side
+     */
+    LocationComponentLayer::LocationComponentLayer(jni::JNIEnv& env, jni::String& layerId)
+        : Layer(std::make_unique<mbgl::style::LocationComponentLayer>(jni::Make<std::string>(env, layerId))) {
+    }
+
+    /**
+     * Creates a non-owning peer object (for layers currently attached to the map)
+     */
+    LocationComponentLayer::LocationComponentLayer(mbgl::style::LocationComponentLayer& coreLayer)
+        : Layer(coreLayer) {
+    }
+
+    /**
+     * Creates an owning peer object (for layers not attached to the map)
+     */
+    LocationComponentLayer::LocationComponentLayer(std::unique_ptr<mbgl::style::LocationComponentLayer> coreLayer)
+        : Layer(std::move(coreLayer)) {
+    }
+
+    LocationComponentLayer::~LocationComponentLayer() = default;
+
+    // Property getters
+
+    jni::Local<jni::Object<>> LocationComponentLayer::getTopImage(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationComponentLayer(layer).getTopImage()));
+    }
+
+    jni::Local<jni::Object<>> LocationComponentLayer::getBearingImage(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationComponentLayer(layer).getBearingImage()));
+    }
+
+    jni::Local<jni::Object<>> LocationComponentLayer::getShadowImage(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationComponentLayer(layer).getShadowImage()));
+    }
+
+    jni::Local<jni::Object<>> LocationComponentLayer::getLocation(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationComponentLayer(layer).getLocation()));
+    }
+
+    jni::Local<jni::Object<>> LocationComponentLayer::getBearing(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationComponentLayer(layer).getBearing()));
+    }
+
+    jni::Local<jni::Object<>> LocationComponentLayer::getAccuracyRadius(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationComponentLayer(layer).getAccuracyRadius()));
+    }
+
+    jni::Local<jni::Object<>> LocationComponentLayer::getTopImageSize(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationComponentLayer(layer).getTopImageSize()));
+    }
+
+    jni::Local<jni::Object<>> LocationComponentLayer::getBearingImageSize(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationComponentLayer(layer).getBearingImageSize()));
+    }
+
+    jni::Local<jni::Object<>> LocationComponentLayer::getShadowImageSize(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationComponentLayer(layer).getShadowImageSize()));
+    }
+
+    jni::Local<jni::Object<>> LocationComponentLayer::getPerspectiveCompensation(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationComponentLayer(layer).getPerspectiveCompensation()));
+    }
+
+    jni::Local<jni::Object<>> LocationComponentLayer::getImageTiltDisplacement(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationComponentLayer(layer).getImageTiltDisplacement()));
+    }
+
+    jni::Local<jni::Object<>> LocationComponentLayer::getAccuracyRadiusColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationComponentLayer(layer).getAccuracyRadiusColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> LocationComponentLayer::getAccuracyRadiusColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toLocationComponentLayer(layer).getAccuracyRadiusColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void LocationComponentLayer::setAccuracyRadiusColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toLocationComponentLayer(layer).setAccuracyRadiusColorTransition(options);
+    }
+
+    jni::Local<jni::Object<>> LocationComponentLayer::getAccuracyRadiusBorderColor(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, toLocationComponentLayer(layer).getAccuracyRadiusBorderColor()));
+    }
+
+    jni::Local<jni::Object<TransitionOptions>> LocationComponentLayer::getAccuracyRadiusBorderColorTransition(jni::JNIEnv& env) {
+        using namespace mbgl::android::conversion;
+        mbgl::style::TransitionOptions options = toLocationComponentLayer(layer).getAccuracyRadiusBorderColorTransition();
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+    }
+
+    void LocationComponentLayer::setAccuracyRadiusBorderColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+        mbgl::style::TransitionOptions options;
+        options.duration.emplace(mbgl::Milliseconds(duration));
+        options.delay.emplace(mbgl::Milliseconds(delay));
+        toLocationComponentLayer(layer).setAccuracyRadiusBorderColorTransition(options);
+    }
+
+
+    // LocationComponentJavaLayerPeerFactory
+
+    LocationComponentJavaLayerPeerFactory::~LocationComponentJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<LocationComponentLayer>::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>> LocationComponentJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env, new LocationComponentLayer(toLocationComponentLayer(layer)));
+    }
+
+    jni::Local<jni::Object<Layer>> LocationComponentJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
+        return createJavaPeer(env, new LocationComponentLayer(std::unique_ptr<mbgl::style::LocationComponentLayer>(static_cast<mbgl::style::LocationComponentLayer*>(layer.release()))));
+    }
+
+    void LocationComponentJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+        // Lookup the class
+        static auto& javaClass = jni::Class<LocationComponentLayer>::Singleton(env);
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        // Register the peer
+        jni::RegisterNativePeer<LocationComponentLayer>(
+            env,
+            javaClass,
+            "nativePtr",
+            jni::MakePeer<LocationComponentLayer, jni::String&>,
+            "initialize",
+            "finalize",
+            METHOD(&LocationComponentLayer::getTopImage, "nativeGetTopImage"),
+            METHOD(&LocationComponentLayer::getBearingImage, "nativeGetBearingImage"),
+            METHOD(&LocationComponentLayer::getShadowImage, "nativeGetShadowImage"),
+            METHOD(&LocationComponentLayer::getLocation, "nativeGetLocation"),
+            METHOD(&LocationComponentLayer::getBearing, "nativeGetBearing"),
+            METHOD(&LocationComponentLayer::getAccuracyRadius, "nativeGetAccuracyRadius"),
+            METHOD(&LocationComponentLayer::getTopImageSize, "nativeGetTopImageSize"),
+            METHOD(&LocationComponentLayer::getBearingImageSize, "nativeGetBearingImageSize"),
+            METHOD(&LocationComponentLayer::getShadowImageSize, "nativeGetShadowImageSize"),
+            METHOD(&LocationComponentLayer::getPerspectiveCompensation, "nativeGetPerspectiveCompensation"),
+            METHOD(&LocationComponentLayer::getImageTiltDisplacement, "nativeGetImageTiltDisplacement"),
+            METHOD(&LocationComponentLayer::getAccuracyRadiusColorTransition, "nativeGetAccuracyRadiusColorTransition"),
+            METHOD(&LocationComponentLayer::setAccuracyRadiusColorTransition, "nativeSetAccuracyRadiusColorTransition"),
+            METHOD(&LocationComponentLayer::getAccuracyRadiusColor, "nativeGetAccuracyRadiusColor"),
+            METHOD(&LocationComponentLayer::getAccuracyRadiusBorderColorTransition, "nativeGetAccuracyRadiusBorderColorTransition"),
+            METHOD(&LocationComponentLayer::setAccuracyRadiusBorderColorTransition, "nativeSetAccuracyRadiusBorderColorTransition"),
+            METHOD(&LocationComponentLayer::getAccuracyRadiusBorderColor, "nativeGetAccuracyRadiusBorderColor"));
+    }
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/layers/location_component_layer.hpp b/platform/android/src/style/layers/location_component_layer.hpp
new file mode 100644
index 0000000000..ca2ec47072
--- /dev/null
+++ b/platform/android/src/style/layers/location_component_layer.hpp
@@ -0,0 +1,76 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include "layer.hpp"
+#include "../transition_options.hpp"
+#include <mbgl/layermanager/location_component_layer_factory.hpp>
+#include <mbgl/style/layers/location_component_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class LocationComponentLayer : public Layer {
+public:
+    using SuperTag = Layer;
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/LocationComponentLayer"; };
+
+    LocationComponentLayer(jni::JNIEnv&, jni::String&);
+
+    LocationComponentLayer(mbgl::style::LocationComponentLayer&);
+
+    LocationComponentLayer(std::unique_ptr<mbgl::style::LocationComponentLayer>);
+
+    ~LocationComponentLayer();
+
+    // Properties
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTopImage(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getBearingImage(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getShadowImage(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getLocation(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getBearing(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getAccuracyRadius(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getTopImageSize(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getBearingImageSize(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getShadowImageSize(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getPerspectiveCompensation(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getImageTiltDisplacement(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getAccuracyRadiusColor(jni::JNIEnv&);
+    void setAccuracyRadiusColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getAccuracyRadiusColorTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getAccuracyRadiusBorderColor(jni::JNIEnv&);
+    void setAccuracyRadiusBorderColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getAccuracyRadiusBorderColorTransition(jni::JNIEnv&);
+
+}; // class LocationComponentLayer
+
+class LocationComponentJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::LocationComponentLayerFactory {
+public:
+    ~LocationComponentJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    LayerFactory* getLayerFactory() final { return this; }
+
+};  // class LocationComponentJavaLayerPeerFactory
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/layers/raster_layer.cpp b/platform/android/src/style/layers/raster_layer.cpp
index d9cce949c2..53442c0a94 100644
--- a/platform/android/src/style/layers/raster_layer.cpp
+++ b/platform/android/src/style/layers/raster_layer.cpp
@@ -26,12 +26,16 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    RasterLayer::RasterLayer(mbgl::style::RasterLayer& coreLayer) : Layer(coreLayer) {}
+    RasterLayer::RasterLayer(mbgl::style::RasterLayer& coreLayer)
+        : Layer(coreLayer) {
+    }
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    RasterLayer::RasterLayer(std::unique_ptr<mbgl::style::RasterLayer> coreLayer) : Layer(std::move(coreLayer)) {}
+    RasterLayer::RasterLayer(std::unique_ptr<mbgl::style::RasterLayer> coreLayer)
+        : Layer(std::move(coreLayer)) {
+    }
 
     RasterLayer::~RasterLayer() = default;
 
@@ -168,18 +172,14 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> RasterJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
-                                                                                   mbgl::style::Layer& 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) {
+    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()))));
+        return createJavaPeer(env, new RasterLayer(std::unique_ptr<mbgl::style::RasterLayer>(static_cast<mbgl::style::RasterLayer*>(layer.release()))));
     }
 
     void RasterJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
diff --git a/platform/android/src/style/layers/symbol_layer.cpp b/platform/android/src/style/layers/symbol_layer.cpp
index f24fb35425..198dbe635f 100644
--- a/platform/android/src/style/layers/symbol_layer.cpp
+++ b/platform/android/src/style/layers/symbol_layer.cpp
@@ -26,12 +26,16 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    SymbolLayer::SymbolLayer(mbgl::style::SymbolLayer& coreLayer) : Layer(coreLayer) {}
+    SymbolLayer::SymbolLayer(mbgl::style::SymbolLayer& coreLayer)
+        : Layer(coreLayer) {
+    }
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    SymbolLayer::SymbolLayer(std::unique_ptr<mbgl::style::SymbolLayer> coreLayer) : Layer(std::move(coreLayer)) {}
+    SymbolLayer::SymbolLayer(std::unique_ptr<mbgl::style::SymbolLayer> coreLayer)
+        : Layer(std::move(coreLayer)) {
+    }
 
     SymbolLayer::~SymbolLayer() = default;
 
@@ -481,18 +485,14 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> SymbolJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
-                                                                                   mbgl::style::Layer& layer) {
+    jni::Local<jni::Object<Layer>> SymbolJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::style::Layer& layer) {
         assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
         return createJavaPeer(env, new SymbolLayer(toSymbolLayer(layer)));
     }
 
-    jni::Local<jni::Object<Layer>> SymbolJavaLayerPeerFactory::createJavaLayerPeer(
-        jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+    jni::Local<jni::Object<Layer>> SymbolJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
         assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
-        return createJavaPeer(env,
-                              new SymbolLayer(std::unique_ptr<mbgl::style::SymbolLayer>(
-                                  static_cast<mbgl::style::SymbolLayer*>(layer.release()))));
+        return createJavaPeer(env, new SymbolLayer(std::unique_ptr<mbgl::style::SymbolLayer>(static_cast<mbgl::style::SymbolLayer*>(layer.release()))));
     }
 
     void SymbolJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs
index 397e85b51e..0aed9f6f44 100644
--- a/src/mbgl/style/layers/layer.cpp.ejs
+++ b/src/mbgl/style/layers/layer.cpp.ejs
@@ -100,7 +100,7 @@ const LayerTypeInfo* <%- camelize(type) %>Layer::Impl::staticTypeInfo() noexcept
 }
 
 
-<% if ((type === 'background') || (type === 'location-component')) { -%>
+<% if (type === 'background' || type === 'location-component') { -%>
 <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(const std::string& layerID)
     : Layer(makeMutable<Impl>(layerID, std::string())) {
 }