[core][android] Implement LayerManager for Android

The newly introduced `LayerManagerAndroid` is now responsible
for creating both style layer objects and their java peers on Android.

platform/android/src/jni.cpp

@@ -160,7 +160,7 @@ void registerNatives(JavaVM *vm) {
 
     // Style
     TransitionOptions::registerNative(env);
-    registerNativeLayers(env);
+    LayerManagerAndroid::get()->registerNative(env);
     Source::registerNative(env);
     Light::registerNative(env);
     Position::registerNative(env);

platform/android/src/native_map_view.cpp

@@ -733,7 +733,7 @@ jni::Local<jni::Array<jni::Object<Layer>>> NativeMapView::getLayers(JNIEnv& env)
     auto jLayers = jni::Array<jni::Object<Layer>>::New(env, layers.size());
     int index = 0;
     for (auto layer : layers) {
-        jLayers.Set(env, index, createJavaLayerPeer(env, *map, *layer));
+        jLayers.Set(env, index, LayerManagerAndroid::get()->createJavaLayerPeer(env, *map, *layer));
         index++;
     }
 
@@ -750,7 +750,7 @@ jni::Local<jni::Object<Layer>> NativeMapView::getLayer(JNIEnv& env, const jni::S
     }
 
     // Create and return the layer's native peer
-    return createJavaLayerPeer(env, *map, *coreLayer);
+    return LayerManagerAndroid::get()->createJavaLayerPeer(env, *map, *coreLayer);
 }
 
 void NativeMapView::addLayer(JNIEnv& env, jlong nativeLayerPtr, const jni::String& before) {
@@ -830,7 +830,7 @@ void NativeMapView::addLayerAt(JNIEnv& env, jlong nativeLayerPtr, jni::jint inde
 jni::Local<jni::Object<Layer>> NativeMapView::removeLayerById(JNIEnv& env, const jni::String& id) {
     std::unique_ptr<mbgl::style::Layer> coreLayer = map->getStyle().removeLayer(jni::Make<std::string>(env, id));
     if (coreLayer) {
-        return createJavaLayerPeer(env, *map, std::move(coreLayer));
+        return LayerManagerAndroid::get()->createJavaLayerPeer(env, *map, std::move(coreLayer));
     } else {
         return jni::Local<jni::Object<Layer>>();
     }
@@ -851,7 +851,7 @@ jni::Local<jni::Object<Layer>> NativeMapView::removeLayerAt(JNIEnv& env, jni::ji
 
     std::unique_ptr<mbgl::style::Layer> coreLayer = map->getStyle().removeLayer(layers.at(index)->getID());
     if (coreLayer) {
-        return createJavaLayerPeer(env, *map, std::move(coreLayer));
+        return LayerManagerAndroid::get()->createJavaLayerPeer(env, *map, std::move(coreLayer));
     } else {
         return jni::Local<jni::Object<Layer>>();
     }

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

@@ -7,6 +7,8 @@
 #include "../conversion/property_value.hpp"
 #include "../conversion/transition_options.hpp"
 
+#include <mbgl/style/layer_impl.hpp>
+
 namespace mbgl {
 namespace android {
 
@@ -18,7 +20,7 @@ namespace android {
      * 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(env, std::make_unique<mbgl::style::BackgroundLayer>(jni::Make<std::string>(env, layerId))) {
+        : Layer(std::make_unique<mbgl::style::BackgroundLayer>(jni::Make<std::string>(env, layerId))) {
     }
 
     /**
@@ -94,13 +96,29 @@ namespace android {
     }
 
 
-    jni::Local<jni::Object<Layer>> BackgroundLayer::createJavaPeer(jni::JNIEnv& env) {
-        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>(this));
+    // BackgroundJavaLayerPeerFactory
+
+    BackgroundJavaLayerPeerFactory::~BackgroundJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<BackgroundLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> BackgroundJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new BackgroundLayer(map, toBackgroundLayer(layer)));
     }
 
-    void BackgroundLayer::registerNative(jni::JNIEnv& env) {
+    jni::Local<jni::Object<Layer>> BackgroundJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new BackgroundLayer(map, 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);
 

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

@@ -15,8 +15,6 @@ public:
     using SuperTag = Layer;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/BackgroundLayer"; };
 
-    static void registerNative(jni::JNIEnv&);
-
     BackgroundLayer(jni::JNIEnv&, jni::String&);
 
     BackgroundLayer(mbgl::Map&, mbgl::style::BackgroundLayer&);
@@ -38,9 +36,22 @@ public:
     jni::Local<jni::Object<jni::ObjectTag>> getBackgroundOpacity(jni::JNIEnv&);
     void setBackgroundOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
     jni::Local<jni::Object<TransitionOptions>> getBackgroundOpacityTransition(jni::JNIEnv&);
-    jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
 
 }; // class BackgroundLayer
 
+class BackgroundJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::style::BackgroundLayerFactory {
+public:
+    ~BackgroundJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    style::LayerFactory* getLayerFactory() final { return this; }
+
+};  // class BackgroundJavaLayerPeerFactory
+
 } // namespace android
 } // namespace mbgl

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

@@ -7,6 +7,8 @@
 #include "../conversion/property_value.hpp"
 #include "../conversion/transition_options.hpp"
 
+#include <mbgl/style/layer_impl.hpp>
+
 namespace mbgl {
 namespace android {
 
@@ -18,7 +20,7 @@ namespace android {
      * 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(env, std::make_unique<mbgl::style::CircleLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+        : Layer(std::make_unique<mbgl::style::CircleLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
     }
 
     /**
@@ -199,13 +201,29 @@ namespace android {
     }
 
 
-    jni::Local<jni::Object<Layer>> CircleLayer::createJavaPeer(jni::JNIEnv& env) {
-        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>(this));
+    // CircleJavaLayerPeerFactory
+
+    CircleJavaLayerPeerFactory::~CircleJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<CircleLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> CircleJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new CircleLayer(map, toCircleLayer(layer)));
     }
 
-    void CircleLayer::registerNative(jni::JNIEnv& env) {
+    jni::Local<jni::Object<Layer>> CircleJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new CircleLayer(map, 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);
 

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

@@ -15,8 +15,6 @@ public:
     using SuperTag = Layer;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/CircleLayer"; };
 
-    static void registerNative(jni::JNIEnv&);
-
     CircleLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
     CircleLayer(mbgl::Map&, mbgl::style::CircleLayer&);
@@ -64,9 +62,22 @@ public:
     jni::Local<jni::Object<jni::ObjectTag>> getCircleStrokeOpacity(jni::JNIEnv&);
     void setCircleStrokeOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
     jni::Local<jni::Object<TransitionOptions>> getCircleStrokeOpacityTransition(jni::JNIEnv&);
-    jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
 
 }; // class CircleLayer
 
+class CircleJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::style::CircleLayerFactory {
+public:
+    ~CircleJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    style::LayerFactory* getLayerFactory() final { return this; }
+
+};  // class CircleJavaLayerPeerFactory
+
 } // namespace android
 } // namespace mbgl

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

@@ -8,7 +8,7 @@ namespace mbgl {
 namespace android {
 
     CustomLayer::CustomLayer(jni::JNIEnv& env, const jni::String& layerId, jni::jlong host)
-        : Layer(env, std::make_unique<mbgl::style::CustomLayer>(
+        : 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)))
                 ) {
@@ -19,7 +19,7 @@ namespace android {
     }
 
     CustomLayer::CustomLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::CustomLayer> coreLayer)
-            : Layer(map, std::move(coreLayer)) {
+        : Layer(map, std::move(coreLayer)) {
     }
 
     CustomLayer::~CustomLayer() = default;
@@ -33,13 +33,25 @@ namespace android {
         }
     }
 
-    jni::Local<jni::Object<Layer>> CustomLayer::createJavaPeer(jni::JNIEnv& env) {
-        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>(this));
+    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));
+        }
     }
 
-    void CustomLayer::registerNative(jni::JNIEnv& env) {
+    CustomJavaLayerPeerFactory::~CustomJavaLayerPeerFactory() = default;
+
+    jni::Local<jni::Object<Layer>> CustomJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& layer) {
+        return createJavaPeer(env, new CustomLayer(map, static_cast<mbgl::style::CustomLayer&>(layer)));
+    }
+
+    jni::Local<jni::Object<Layer>> CustomJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+        return createJavaPeer(env, new CustomLayer(map, 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);
 

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

@@ -25,5 +25,19 @@ public:
 
 }; // class CustomLayer
 
+class CustomJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::style::CustomLayerFactory {
+public:
+    ~CustomJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    style::LayerFactory* getLayerFactory() final { return this; }
+
+};  // class CustomJavaLayerPeerFactory
+
 } // namespace android
 } // namespace mbgl

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

@@ -7,6 +7,8 @@
 #include "../conversion/property_value.hpp"
 #include "../conversion/transition_options.hpp"
 
+#include <mbgl/style/layer_impl.hpp>
+
 namespace mbgl {
 namespace android {
 
@@ -18,7 +20,7 @@ namespace android {
      * 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(env, std::make_unique<mbgl::style::FillExtrusionLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+        : Layer(std::make_unique<mbgl::style::FillExtrusionLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
     }
 
     /**
@@ -153,13 +155,29 @@ namespace android {
     }
 
 
-    jni::Local<jni::Object<Layer>> FillExtrusionLayer::createJavaPeer(jni::JNIEnv& env) {
-        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>(this));
+    // FillExtrusionJavaLayerPeerFactory
+
+    FillExtrusionJavaLayerPeerFactory::~FillExtrusionJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<FillExtrusionLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> FillExtrusionJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new FillExtrusionLayer(map, toFillExtrusionLayer(layer)));
     }
 
-    void FillExtrusionLayer::registerNative(jni::JNIEnv& env) {
+    jni::Local<jni::Object<Layer>> FillExtrusionJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new FillExtrusionLayer(map, 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);
 

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

@@ -15,8 +15,6 @@ public:
     using SuperTag = Layer;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/FillExtrusionLayer"; };
 
-    static void registerNative(jni::JNIEnv&);
-
     FillExtrusionLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
     FillExtrusionLayer(mbgl::Map&, mbgl::style::FillExtrusionLayer&);
@@ -52,9 +50,22 @@ public:
     jni::Local<jni::Object<jni::ObjectTag>> getFillExtrusionBase(jni::JNIEnv&);
     void setFillExtrusionBaseTransition(jni::JNIEnv&, jlong duration, jlong delay);
     jni::Local<jni::Object<TransitionOptions>> getFillExtrusionBaseTransition(jni::JNIEnv&);
-    jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
 
 }; // class FillExtrusionLayer
 
+class FillExtrusionJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::style::FillExtrusionLayerFactory {
+public:
+    ~FillExtrusionJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    style::LayerFactory* getLayerFactory() final { return this; }
+
+};  // class FillExtrusionJavaLayerPeerFactory
+
 } // namespace android
 } // namespace mbgl

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

@@ -7,6 +7,8 @@
 #include "../conversion/property_value.hpp"
 #include "../conversion/transition_options.hpp"
 
+#include <mbgl/style/layer_impl.hpp>
+
 namespace mbgl {
 namespace android {
 
@@ -18,7 +20,7 @@ namespace android {
      * 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(env, std::make_unique<mbgl::style::FillLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+        : Layer(std::make_unique<mbgl::style::FillLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
     }
 
     /**
@@ -140,13 +142,29 @@ namespace android {
     }
 
 
-    jni::Local<jni::Object<Layer>> FillLayer::createJavaPeer(jni::JNIEnv& env) {
-        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>(this));
+    // FillJavaLayerPeerFactory
+
+    FillJavaLayerPeerFactory::~FillJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<FillLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> FillJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new FillLayer(map, toFillLayer(layer)));
     }
 
-    void FillLayer::registerNative(jni::JNIEnv& env) {
+    jni::Local<jni::Object<Layer>> FillJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new FillLayer(map, 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);
 

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

@@ -15,8 +15,6 @@ public:
     using SuperTag = Layer;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/FillLayer"; };
 
-    static void registerNative(jni::JNIEnv&);
-
     FillLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
     FillLayer(mbgl::Map&, mbgl::style::FillLayer&);
@@ -50,9 +48,22 @@ public:
     jni::Local<jni::Object<jni::ObjectTag>> getFillPattern(jni::JNIEnv&);
     void setFillPatternTransition(jni::JNIEnv&, jlong duration, jlong delay);
     jni::Local<jni::Object<TransitionOptions>> getFillPatternTransition(jni::JNIEnv&);
-    jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
 
 }; // class FillLayer
 
+class FillJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::style::FillLayerFactory {
+public:
+    ~FillJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    style::LayerFactory* getLayerFactory() final { return this; }
+
+};  // class FillJavaLayerPeerFactory
+
 } // namespace android
 } // namespace mbgl

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

@@ -7,6 +7,8 @@
 #include "../conversion/property_value.hpp"
 #include "../conversion/transition_options.hpp"
 
+#include <mbgl/style/layer_impl.hpp>
+
 namespace mbgl {
 namespace android {
 
@@ -18,7 +20,7 @@ namespace android {
      * 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(env, std::make_unique<mbgl::style::HeatmapLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+        : Layer(std::make_unique<mbgl::style::HeatmapLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
     }
 
     /**
@@ -108,13 +110,29 @@ namespace android {
     }
 
 
-    jni::Local<jni::Object<Layer>> HeatmapLayer::createJavaPeer(jni::JNIEnv& env) {
-        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>(this));
+    // 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::Map& map, mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new HeatmapLayer(map, toHeatmapLayer(layer)));
     }
 
-    void HeatmapLayer::registerNative(jni::JNIEnv& env) {
+    jni::Local<jni::Object<Layer>> HeatmapJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new HeatmapLayer(map, 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);
 

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

@@ -15,8 +15,6 @@ public:
     using SuperTag = Layer;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/HeatmapLayer"; };
 
-    static void registerNative(jni::JNIEnv&);
-
     HeatmapLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
     HeatmapLayer(mbgl::Map&, mbgl::style::HeatmapLayer&);
@@ -42,9 +40,22 @@ public:
     jni::Local<jni::Object<jni::ObjectTag>> getHeatmapOpacity(jni::JNIEnv&);
     void setHeatmapOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
     jni::Local<jni::Object<TransitionOptions>> getHeatmapOpacityTransition(jni::JNIEnv&);
-    jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
 
 }; // class HeatmapLayer
 
+class HeatmapJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::style::HeatmapLayerFactory {
+public:
+    ~HeatmapJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    style::LayerFactory* getLayerFactory() final { return this; }
+
+};  // class HeatmapJavaLayerPeerFactory
+
 } // namespace android
 } // namespace mbgl

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

@@ -7,6 +7,8 @@
 #include "../conversion/property_value.hpp"
 #include "../conversion/transition_options.hpp"
 
+#include <mbgl/style/layer_impl.hpp>
+
 namespace mbgl {
 namespace android {
 
@@ -18,7 +20,7 @@ namespace android {
      * 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(env, std::make_unique<mbgl::style::HillshadeLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+        : Layer(std::make_unique<mbgl::style::HillshadeLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
     }
 
     /**
@@ -122,13 +124,29 @@ namespace android {
     }
 
 
-    jni::Local<jni::Object<Layer>> HillshadeLayer::createJavaPeer(jni::JNIEnv& env) {
-        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>(this));
+    // HillshadeJavaLayerPeerFactory
+
+    HillshadeJavaLayerPeerFactory::~HillshadeJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<HillshadeLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> HillshadeJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new HillshadeLayer(map, toHillshadeLayer(layer)));
     }
 
-    void HillshadeLayer::registerNative(jni::JNIEnv& env) {
+    jni::Local<jni::Object<Layer>> HillshadeJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new HillshadeLayer(map, 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);
 

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

@@ -15,8 +15,6 @@ public:
     using SuperTag = Layer;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/HillshadeLayer"; };
 
-    static void registerNative(jni::JNIEnv&);
-
     HillshadeLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
     HillshadeLayer(mbgl::Map&, mbgl::style::HillshadeLayer&);
@@ -46,9 +44,22 @@ public:
     jni::Local<jni::Object<jni::ObjectTag>> getHillshadeAccentColor(jni::JNIEnv&);
     void setHillshadeAccentColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
     jni::Local<jni::Object<TransitionOptions>> getHillshadeAccentColorTransition(jni::JNIEnv&);
-    jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
 
 }; // class HillshadeLayer
 
+class HillshadeJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::style::HillshadeLayerFactory {
+public:
+    ~HillshadeJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    style::LayerFactory* getLayerFactory() final { return this; }
+
+};  // class HillshadeJavaLayerPeerFactory
+
 } // namespace android
 } // namespace mbgl

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

@@ -37,7 +37,7 @@ namespace android {
     /**
      * Invoked when the construction is initiated from the jvm through a subclass
      */
-    Layer::Layer(jni::JNIEnv&, std::unique_ptr<mbgl::style::Layer> coreLayer)
+    Layer::Layer(std::unique_ptr<mbgl::style::Layer> coreLayer)
         : ownedLayer(std::move(coreLayer))
         , layer(*ownedLayer) {
     }

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

@@ -11,6 +11,8 @@
 #include "../conversion/property_value.hpp"
 #include "../conversion/transition_options.hpp"
 
+#include <mbgl/style/layer_impl.hpp>
+
 namespace mbgl {
 namespace android {
 
@@ -23,13 +25,13 @@ namespace android {
      * Creates an owning peer object (for layers not attached to the map) from the JVM side
      */
     <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(jni::JNIEnv& env, jni::String& layerId)
-        : Layer(env, std::make_unique<mbgl::style::<%- camelize(type) %>Layer>(jni::Make<std::string>(env, layerId))) {
+        : Layer(std::make_unique<mbgl::style::<%- camelize(type) %>Layer>(jni::Make<std::string>(env, layerId))) {
 <% } else { -%>
     /**
      * Creates an owning peer object (for layers not attached to the map) from the JVM side
      */
     <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
-        : Layer(env, std::make_unique<mbgl::style::<%- camelize(type) %>Layer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+        : Layer(std::make_unique<mbgl::style::<%- camelize(type) %>Layer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
 <% } -%>
     }
 
@@ -86,13 +88,29 @@ namespace android {
 <% } -%>
 <% } -%>
 
-    jni::Local<jni::Object<Layer>> <%- camelize(type) %>Layer::createJavaPeer(jni::JNIEnv& env) {
-        static auto& javaClass = jni::Class<<%- camelize(type) %>Layer>::Singleton(env);
-        static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
-        return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+    // <%- camelize(type) %>JavaLayerPeerFactory
+
+    <%- camelize(type) %>JavaLayerPeerFactory::~<%- camelize(type) %>JavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<<%- camelize(type) %>Layer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> <%- camelize(type) %>JavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new <%- camelize(type) %>Layer(map, to<%- camelize(type) %>Layer(layer)));
     }
 
-    void <%- camelize(type) %>Layer::registerNative(jni::JNIEnv& env) {
+    jni::Local<jni::Object<Layer>> <%- camelize(type) %>JavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new <%- camelize(type) %>Layer(map, std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer>(static_cast<mbgl::style::<%- camelize(type) %>Layer*>(layer.release()))));
+    }
+
+    void <%- camelize(type) %>JavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
         // Lookup the class
         static auto& javaClass = jni::Class<<%- camelize(type) %>Layer>::Singleton(env);
 

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

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <mbgl/util/noncopyable.hpp>
 #include <mbgl/map/map.hpp>
 #include <mbgl/style/layer.hpp>
 #include "../../gson/json_array.hpp"
@@ -11,35 +10,17 @@
 
 namespace mbgl {
 
-
 namespace android {
 
-class Layer : private mbgl::util::noncopyable {
+class Layer {
 public:
 
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/Layer"; };
 
     static void registerNative(jni::JNIEnv&);
 
-    /*
-     * Called when a non-owning peer object is created on the c++ side
-     */
-    Layer(mbgl::Map&, mbgl::style::Layer&);
-
-    /*
-     * Called when a owning peer object is created on the c++ side
-     */
-    Layer(mbgl::Map&, std::unique_ptr<mbgl::style::Layer>);
-
-    /*
-     * Called when a Java object was created from the jvm side
-     */
-    Layer(jni::JNIEnv&, std::unique_ptr<mbgl::style::Layer>);
-
     virtual ~Layer();
 
-    virtual jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&) = 0;
-
     /**
      * Set core layer (ie return ownership after remove)
      */
@@ -82,6 +63,21 @@ public:
     jni::Local<jni::Object<jni::ObjectTag>> getVisibility(jni::JNIEnv&);
 
 protected:
+    /*
+     * Called when a non-owning peer object is created on the c++ side
+     */
+    Layer(mbgl::Map&, mbgl::style::Layer&);
+
+    /*
+     * Called when a owning peer object is created on the c++ side
+     */
+    Layer(mbgl::Map&, std::unique_ptr<mbgl::style::Layer>);
+
+    /*
+     * Called when a Java object was created from the jvm side
+     */
+    Layer(std::unique_ptr<mbgl::style::Layer>);
+
     // Release the owned view and return it
     std::unique_ptr<mbgl::style::Layer> releaseCoreLayer();
 
@@ -95,5 +91,35 @@ protected:
     mbgl::Map* map;
 };
 
+/**
+ * @brief A factory class for a layer Java peer objects of a certain type.
+ */
+class JavaLayerPeerFactory {
+public:
+    virtual ~JavaLayerPeerFactory() = default;
+    /**
+     * @brief Create a non-owning peer.
+     */
+    virtual jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&) = 0;
+
+    /**
+     * @brief Create an owning peer.
+     */
+    virtual jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>) = 0;
+
+    /**
+     * @brief Register peer methods.
+     */
+    virtual void registerNative(jni::JNIEnv&) = 0;
+
+    /**
+     * @brief Get the corresponding layer factory.
+     * 
+     * @return style::LayerFactory* must not be \c nullptr.
+     */
+    virtual style::LayerFactory* getLayerFactory() = 0;
+};
+
+
 } // namespace android
 } // namespace mbgl

platform/android/src/style/layers/layer.hpp.ejs

@@ -19,8 +19,6 @@ public:
     using SuperTag = Layer;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/<%- camelize(type) %>Layer"; };
 
-    static void registerNative(jni::JNIEnv&);
-
 <% if (type === 'background') { -%>
     <%- camelize(type) %>Layer(jni::JNIEnv&, jni::String&);
 <% } else { -%>
@@ -42,9 +40,22 @@ public:
     jni::Local<jni::Object<TransitionOptions>> get<%- camelize(property.name) %>Transition(jni::JNIEnv&);
 <% } -%>
 <% } -%>
-    jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
 
 }; // class <%- camelize(type) %>Layer
 
+class <%- camelize(type) %>JavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::style::<%- camelize(type) %>LayerFactory {
+public:
+    ~<%- camelize(type) %>JavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    style::LayerFactory* getLayerFactory() final { return this; }
+
+};  // class <%- camelize(type) %>JavaLayerPeerFactory
+
 } // namespace android
 } // namespace mbgl

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

@@ -1,6 +1,7 @@
 #include "layers.hpp"
 
 #include <mbgl/style/layer.hpp>
+#include <mbgl/style/layer_impl.hpp>
 #include <mbgl/style/layers/background_layer.hpp>
 #include <mbgl/style/layers/circle_layer.hpp>
 #include <mbgl/style/layers/fill_extrusion_layer.hpp>
@@ -12,6 +13,10 @@
 #include <mbgl/style/layers/symbol_layer.hpp>
 #include <mbgl/style/layers/custom_layer.hpp>
 
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/filter.hpp>
+#include <mbgl/style/conversion_impl.hpp>
+
 #include "background_layer.hpp"
 #include "circle_layer.hpp"
 #include "custom_layer.hpp"
@@ -22,81 +27,88 @@
 #include "line_layer.hpp"
 #include "raster_layer.hpp"
 #include "symbol_layer.hpp"
-#include "unknown_layer.hpp"
 #include "fill_extrusion_layer.hpp"
 
 namespace mbgl {
 
 namespace android {
 
-template <typename T>
-inline std::unique_ptr<T> to(std::unique_ptr<style::Layer> layer) {
-    return std::unique_ptr<T>(static_cast<T*>(layer.release()));
+LayerManagerAndroid::LayerManagerAndroid() {
+    factories.emplace_back(std::unique_ptr<JavaLayerPeerFactory>(new FillJavaLayerPeerFactory));
+    factories.emplace_back(std::unique_ptr<JavaLayerPeerFactory>(new LineJavaLayerPeerFactory));
+    factories.emplace_back(std::unique_ptr<JavaLayerPeerFactory>(new CircleJavaLayerPeerFactory));
+    factories.emplace_back(std::unique_ptr<JavaLayerPeerFactory>(new SymbolJavaLayerPeerFactory));
+    factories.emplace_back(std::unique_ptr<JavaLayerPeerFactory>(new RasterJavaLayerPeerFactory));
+    factories.emplace_back(std::unique_ptr<JavaLayerPeerFactory>(new BackgroundJavaLayerPeerFactory));
+    factories.emplace_back(std::unique_ptr<JavaLayerPeerFactory>(new HillshadeJavaLayerPeerFactory));
+    factories.emplace_back(std::unique_ptr<JavaLayerPeerFactory>(new FillExtrusionJavaLayerPeerFactory));
+    factories.emplace_back(std::unique_ptr<JavaLayerPeerFactory>(new HeatmapJavaLayerPeerFactory));
+    factories.emplace_back(std::unique_ptr<JavaLayerPeerFactory>(new CustomJavaLayerPeerFactory));
 }
 
-template <typename T>
-inline T& to(style::Layer& layer) {
-    return static_cast<T&>(layer);
-}
+LayerManagerAndroid::~LayerManagerAndroid() = default;
 
-template <typename T>
-std::unique_ptr<Layer> initializeLayerPeer(Map& map, style::LayerType type, T&& layer) {
-    switch (type) {
-    case style::LayerType::Fill:
-        return std::unique_ptr<Layer>(new FillLayer(map, to<style::FillLayer>(std::forward<T>(layer))));
-    case style::LayerType::Line:
-        return std::unique_ptr<Layer>(new LineLayer(map, to<style::LineLayer>(std::forward<T>(layer))));
-    case style::LayerType::Circle:
-        return std::unique_ptr<Layer>(new CircleLayer(map, to<style::CircleLayer>(std::forward<T>(layer))));
-    case style::LayerType::Symbol:
-        return std::unique_ptr<Layer>(new SymbolLayer(map, to<style::SymbolLayer>(std::forward<T>(layer))));
-    case style::LayerType::Raster:
-        return std::unique_ptr<Layer>(new RasterLayer(map, to<style::RasterLayer>(std::forward<T>(layer))));
-    case style::LayerType::Background:
-        return std::unique_ptr<Layer>(new BackgroundLayer(map, to<style::BackgroundLayer>(std::forward<T>(layer))));
-    case style::LayerType::Hillshade:
-        return std::unique_ptr<Layer>(new HillshadeLayer(map, to<style::HillshadeLayer>(std::forward<T>(layer))));
-    case style::LayerType::Custom:
-        return std::unique_ptr<Layer>(new CustomLayer(map, to<style::CustomLayer>(std::forward<T>(layer))));
-    case style::LayerType::FillExtrusion:
-        return std::unique_ptr<Layer>(new FillExtrusionLayer(map, to<style::FillExtrusionLayer>(std::forward<T>(layer))));
-    case style::LayerType::Heatmap:
-        return std::unique_ptr<Layer>(new HeatmapLayer(map, to<style::HeatmapLayer>(std::forward<T>(layer))));
+jni::Local<jni::Object<Layer>> LayerManagerAndroid::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& layer) {
+    if (JavaLayerPeerFactory* factory = getPeerFactory(&layer)) {
+        return factory->createJavaLayerPeer(env, map, layer);
     }
-    // Not reachable, but placate GCC.
-    assert(false);
-    return std::unique_ptr<Layer>(new UnknownLayer(map, std::forward<T>(layer)));
+    return jni::Local<jni::Object<Layer>>();
 }
 
-jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, Map& map, style::Layer& coreLayer) {
-    std::unique_ptr<Layer> peerLayer = initializeLayerPeer(map, coreLayer.getType(), coreLayer);
-    jni::Local<jni::Object<Layer>> result = peerLayer->createJavaPeer(env);
-    peerLayer.release();
-    return result;
+jni::Local<jni::Object<Layer>> LayerManagerAndroid::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+    if (JavaLayerPeerFactory* factory = getPeerFactory(layer.get())) {
+        return factory->createJavaLayerPeer(env, map, std::move(layer));
+    }
+    return jni::Local<jni::Object<Layer>>();
 }
 
-jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> coreLayer) {
-    auto type = coreLayer->getType();
-    std::unique_ptr<Layer> peerLayer = initializeLayerPeer(map, type, std::move(coreLayer));
-    jni::Local<jni::Object<Layer>> result = peerLayer->createJavaPeer(env);
-    peerLayer.release();
-    return result;
-}
-
-void registerNativeLayers(jni::JNIEnv& env) {
+void LayerManagerAndroid::registerNative(jni::JNIEnv& env) {
     Layer::registerNative(env);
-    BackgroundLayer::registerNative(env);
-    CircleLayer::registerNative(env);
-    CustomLayer::registerNative(env);
-    FillExtrusionLayer::registerNative(env);
-    FillLayer::registerNative(env);
-    HeatmapLayer::registerNative(env);
-    HillshadeLayer::registerNative(env);
-    LineLayer::registerNative(env);
-    RasterLayer::registerNative(env);
-    SymbolLayer::registerNative(env);
-    UnknownLayer::registerNative(env);
+    for (const auto& factory: factories) {
+        factory->registerNative(env);
+    }
+}
+
+JavaLayerPeerFactory* LayerManagerAndroid::getPeerFactory(mbgl::style::Layer* layer) {
+    auto* layerFactory = layer->baseImpl->getLayerFactory();
+    assert(layerFactory);
+    for (const auto& factory: factories) {
+        if (factory->getLayerFactory() == layerFactory) {
+            return factory.get();
+        }
+    }
+    assert(false);
+    return nullptr;
+}
+
+std::unique_ptr<style::Layer> LayerManagerAndroid::createLayer(const std::string& type, const std::string& id, const style::conversion::Convertible& value, style::conversion::Error& error) {
+    for (const auto& factory: factories) {
+        auto* layerFactory = factory->getLayerFactory();
+        if (layerFactory->supportsType(type)) {
+            if (auto layer = layerFactory->createLayer(id, value)) {
+                return layer;
+            }
+            error.message = "Error parsing a layer of type: " + type;
+            return nullptr;
+        }
+    }
+    error.message = "Unsupported layer type: " + type;
+    return nullptr;
+}
+
+// static 
+LayerManagerAndroid* LayerManagerAndroid::get() {
+    static LayerManagerAndroid impl;
+    return &impl;
 }
 
 } // namespace android
+
+namespace style {
+// static 
+LayerManager* LayerManager::get() {
+    return android::LayerManagerAndroid::get();
+}
+
+} // style
 } // namespace mbgl

platform/android/src/style/layers/layers.hpp

@@ -7,20 +7,33 @@
 
 #include <jni/jni.hpp>
 
+#include <memory>
+#include <vector>
+
 namespace mbgl {
 namespace android {
 
 /**
- * Create a non-owning peer
+ * @brief A singleton class forwarding calls to the corresponding  \c JavaLayerPeerFactory instance.
  */
-jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&);
+class LayerManagerAndroid : public mbgl::style::LayerManager {
+public:
+    ~LayerManagerAndroid() override;
+    static LayerManagerAndroid* get();
+    
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&);
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>);
 
-/**
- * Create an owning peer
- */
-jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>);
+    void registerNative(jni::JNIEnv&);
 
-void registerNativeLayers(jni::JNIEnv&);
+private:
+    LayerManagerAndroid();
+    JavaLayerPeerFactory* getPeerFactory(mbgl::style::Layer*);
+    // mbgl:style::LayerManager overrides.
+    std::unique_ptr<style::Layer> createLayer(const std::string& type, const std::string& id, const style::conversion::Convertible& value, style::conversion::Error& error) final;
+
+    std::vector<std::unique_ptr<JavaLayerPeerFactory>> factories;
+};
 
 }
 }

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

@@ -7,6 +7,8 @@
 #include "../conversion/property_value.hpp"
 #include "../conversion/transition_options.hpp"
 
+#include <mbgl/style/layer_impl.hpp>
+
 namespace mbgl {
 namespace android {
 
@@ -18,7 +20,7 @@ namespace android {
      * 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(env, std::make_unique<mbgl::style::LineLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+        : Layer(std::make_unique<mbgl::style::LineLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
     }
 
     /**
@@ -232,13 +234,29 @@ namespace android {
     }
 
 
-    jni::Local<jni::Object<Layer>> LineLayer::createJavaPeer(jni::JNIEnv& env) {
-        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>(this));
+    // LineJavaLayerPeerFactory
+
+    LineJavaLayerPeerFactory::~LineJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<LineLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> LineJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new LineLayer(map, toLineLayer(layer)));
     }
 
-    void LineLayer::registerNative(jni::JNIEnv& env) {
+    jni::Local<jni::Object<Layer>> LineJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new LineLayer(map, 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);
 

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

@@ -15,8 +15,6 @@ public:
     using SuperTag = Layer;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/LineLayer"; };
 
-    static void registerNative(jni::JNIEnv&);
-
     LineLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
     LineLayer(mbgl::Map&, mbgl::style::LineLayer&);
@@ -74,9 +72,22 @@ public:
     jni::Local<jni::Object<TransitionOptions>> getLinePatternTransition(jni::JNIEnv&);
 
     jni::Local<jni::Object<jni::ObjectTag>> getLineGradient(jni::JNIEnv&);
-    jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
 
 }; // class LineLayer
 
+class LineJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::style::LineLayerFactory {
+public:
+    ~LineJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    style::LayerFactory* getLayerFactory() final { return this; }
+
+};  // class LineJavaLayerPeerFactory
+
 } // namespace android
 } // namespace mbgl

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

@@ -7,6 +7,8 @@
 #include "../conversion/property_value.hpp"
 #include "../conversion/transition_options.hpp"
 
+#include <mbgl/style/layer_impl.hpp>
+
 namespace mbgl {
 namespace android {
 
@@ -18,7 +20,7 @@ namespace android {
      * 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(env, std::make_unique<mbgl::style::RasterLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+        : Layer(std::make_unique<mbgl::style::RasterLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
     }
 
     /**
@@ -158,13 +160,29 @@ namespace android {
     }
 
 
-    jni::Local<jni::Object<Layer>> RasterLayer::createJavaPeer(jni::JNIEnv& env) {
-        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>(this));
+    // RasterJavaLayerPeerFactory
+
+    RasterJavaLayerPeerFactory::~RasterJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<RasterLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> RasterJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new RasterLayer(map, toRasterLayer(layer)));
     }
 
-    void RasterLayer::registerNative(jni::JNIEnv& env) {
+    jni::Local<jni::Object<Layer>> RasterJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new RasterLayer(map, 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);
 

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

@@ -15,8 +15,6 @@ public:
     using SuperTag = Layer;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/RasterLayer"; };
 
-    static void registerNative(jni::JNIEnv&);
-
     RasterLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
     RasterLayer(mbgl::Map&, mbgl::style::RasterLayer&);
@@ -54,9 +52,22 @@ public:
     jni::Local<jni::Object<jni::ObjectTag>> getRasterResampling(jni::JNIEnv&);
 
     jni::Local<jni::Object<jni::ObjectTag>> getRasterFadeDuration(jni::JNIEnv&);
-    jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
 
 }; // class RasterLayer
 
+class RasterJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::style::RasterLayerFactory {
+public:
+    ~RasterJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    style::LayerFactory* getLayerFactory() final { return this; }
+
+};  // class RasterJavaLayerPeerFactory
+
 } // namespace android
 } // namespace mbgl

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

@@ -7,6 +7,8 @@
 #include "../conversion/property_value.hpp"
 #include "../conversion/transition_options.hpp"
 
+#include <mbgl/style/layer_impl.hpp>
+
 namespace mbgl {
 namespace android {
 
@@ -18,7 +20,7 @@ namespace android {
      * Creates an owning peer object (for layers not attached to the map) from the JVM side
      */
     SymbolLayer::SymbolLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
-        : Layer(env, std::make_unique<mbgl::style::SymbolLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
+        : Layer(std::make_unique<mbgl::style::SymbolLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
     }
 
     /**
@@ -451,13 +453,29 @@ namespace android {
     }
 
 
-    jni::Local<jni::Object<Layer>> SymbolLayer::createJavaPeer(jni::JNIEnv& env) {
-        static auto& javaClass = jni::Class<SymbolLayer>::Singleton(env);
-        static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
-        return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+    // SymbolJavaLayerPeerFactory
+
+    SymbolJavaLayerPeerFactory::~SymbolJavaLayerPeerFactory() = default;
+
+    namespace {
+        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+            static auto& javaClass = jni::Class<SymbolLayer>::Singleton(env);
+            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+        }
+    }  // namespace
+
+    jni::Local<jni::Object<Layer>> SymbolJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& layer) {
+        assert(layer.baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new SymbolLayer(map, toSymbolLayer(layer)));
     }
 
-    void SymbolLayer::registerNative(jni::JNIEnv& env) {
+    jni::Local<jni::Object<Layer>> SymbolJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+        assert(layer->baseImpl->getLayerFactory() == this);
+        return createJavaPeer(env, new SymbolLayer(map, std::unique_ptr<mbgl::style::SymbolLayer>(static_cast<mbgl::style::SymbolLayer*>(layer.release()))));
+    }
+
+    void SymbolJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
         // Lookup the class
         static auto& javaClass = jni::Class<SymbolLayer>::Singleton(env);
 

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

@@ -15,8 +15,6 @@ public:
     using SuperTag = Layer;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/SymbolLayer"; };
 
-    static void registerNative(jni::JNIEnv&);
-
     SymbolLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
     SymbolLayer(mbgl::Map&, mbgl::style::SymbolLayer&);
@@ -152,9 +150,22 @@ public:
     jni::Local<jni::Object<TransitionOptions>> getTextTranslateTransition(jni::JNIEnv&);
 
     jni::Local<jni::Object<jni::ObjectTag>> getTextTranslateAnchor(jni::JNIEnv&);
-    jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
 
 }; // class SymbolLayer
 
+class SymbolJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::style::SymbolLayerFactory {
+public:
+    ~SymbolJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    style::LayerFactory* getLayerFactory() final { return this; }
+
+};  // class SymbolJavaLayerPeerFactory
+
 } // namespace android
 } // namespace mbgl

platform/android/src/style/layers/unknown_layer.cpp

@@ -22,10 +22,10 @@ namespace android {
         : Layer(map, std::move(coreLayer)) {
     }
 
-    jni::Local<jni::Object<Layer>> UnknownLayer::createJavaPeer(jni::JNIEnv& env) {
+    jni::Local<jni::Object<Layer>> UnknownLayer::createJavaPeer(jni::JNIEnv& env, Layer* layer) {
         static auto& javaClass = jni::Class<UnknownLayer>::Singleton(env);
         static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
-        return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+        return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
     }
 
     void UnknownLayer::registerNative(jni::JNIEnv& env) {

platform/android/src/style/layers/unknown_layer.hpp

@@ -20,7 +20,7 @@ public:
 
     ~UnknownLayer() = default;
 
-    jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
+    static jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&, Layer*);
 
 }; // class UnknownLayer