[android] Add jni binding for styleable snapshotter (#16286)

* [android] Add jni binding for styleable snapshotter

* Remove Map parameter from factories

- remove unused map from factory interfaces. Map is only needed for repaint.

* implement addlayer function

* Implement addsource function for snapshotter

* Implement addImages function

* format codes

* Apply baseline

* Update CHANGELOG.md

* Update map_snapshotter.cpp

* Destroy snapshotter on the thread it was created

* Activate file sources in start

* Use custom deleter for snapshotter

* format codes

* Release snapshotter pointer to deleting lambda

* Clang format

* Update CHANGELOG.md

* Fix review comments

* FIx review comments

Co-authored-by: Alexander Shalamov <alexander.shalamov@mapbox.com>

34 files changed, 429 insertions, 243 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3148c59558..bdb01e4dd6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,8 @@
 
   The newly added `Renderer::clearData()` method allows to clear render data and thus save memory and make sure outdated tiles are not shown. It clears data more agressively than `Renderer::reduceMemoryUse()` does, as it clears not only the cache but all orchestration data, including the data used by the currently rendered frame.
 
+- [android] Add jni binding for styleable snapshotter ([#16286](https://github.com/mapbox/mapbox-gl-native/pull/16286))
+
 ### 🐞 Bug fixes
 
 - [core] Use `TileCoordinates` instead of `LngLat` for `within` expression calculation ([#16319](https://github.com/mapbox/mapbox-gl-native/pull/16319))
diff --git a/metrics/binary-size/android-x86/metrics.json b/metrics/binary-size/android-x86/metrics.json
index d582c959e0..1497e12c08 100644
--- a/metrics/binary-size/android-x86/metrics.json
+++ b/metrics/binary-size/android-x86/metrics.json
@@ -3,7 +3,7 @@
         [
             "android-x86",
             "/tmp/attach/install/android-x86-release/lib/libmapbox-gl.so",
-            1996967
+            1997677
         ]
     ]
 }
\ No newline at end of file
diff --git a/platform/android/src/native_map_view.cpp b/platform/android/src/native_map_view.cpp
index f6e2e4a22f..ddb2e2c3b9 100644
--- a/platform/android/src/native_map_view.cpp
+++ b/platform/android/src/native_map_view.cpp
@@ -909,7 +909,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, LayerManagerAndroid::get()->createJavaLayerPeer(env, *map, *layer));
+        jLayers.Set(env, index, LayerManagerAndroid::get()->createJavaLayerPeer(env, *layer));
         index++;
     }
 
@@ -926,7 +926,7 @@ jni::Local<jni::Object<Layer>> NativeMapView::getLayer(JNIEnv& env, const jni::S
     }
 
     // Create and return the layer's native peer
-    return LayerManagerAndroid::get()->createJavaLayerPeer(env, *map, *coreLayer);
+    return LayerManagerAndroid::get()->createJavaLayerPeer(env, *coreLayer);
 }
 
 void NativeMapView::addLayer(JNIEnv& env, jlong nativeLayerPtr, const jni::String& before) {
@@ -934,7 +934,9 @@ void NativeMapView::addLayer(JNIEnv& env, jlong nativeLayerPtr, const jni::Strin
 
     Layer *layer = reinterpret_cast<Layer *>(nativeLayerPtr);
     try {
-        layer->addToMap(*map, before ? mbgl::optional<std::string>(jni::Make<std::string>(env, before)) : mbgl::optional<std::string>());
+        layer->addToStyle(
+            map->getStyle(),
+            before ? mbgl::optional<std::string>(jni::Make<std::string>(env, before)) : mbgl::optional<std::string>());
     } catch (const std::runtime_error& error) {
         jni::ThrowNew(env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"), error.what());
     }
@@ -971,7 +973,7 @@ void NativeMapView::addLayerAbove(JNIEnv& env, jlong nativeLayerPtr, const jni::
 
     // Add the layer
     try {
-        layer->addToMap(*map, before);
+        layer->addToStyle(map->getStyle(), before);
     } catch (const std::runtime_error& error) {
         jni::ThrowNew(env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"), error.what());
     }
@@ -994,7 +996,7 @@ void NativeMapView::addLayerAt(JNIEnv& env, jlong nativeLayerPtr, jni::jint inde
 
     // Insert it below the current at that index
     try {
-        layer->addToMap(*map, layers.at(index)->getID());
+        layer->addToStyle(map->getStyle(), layers.at(index)->getID());
     } catch (const std::runtime_error& error) {
         jni::ThrowNew(env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"), error.what());
     }
@@ -1017,7 +1019,7 @@ jni::jboolean NativeMapView::removeLayerAt(JNIEnv& env, jni::jint index) {
     std::unique_ptr<mbgl::style::Layer> coreLayer = map->getStyle().removeLayer(layers.at(index)->getID());
     if (coreLayer) {
         jni::Local<jni::Object<Layer>> layerObj =
-                LayerManagerAndroid::get()->createJavaLayerPeer(env, *map, std::move(coreLayer));
+            LayerManagerAndroid::get()->createJavaLayerPeer(env, std::move(coreLayer));
         return jni::jni_true;
     }
     return jni::jni_false;
@@ -1141,6 +1143,11 @@ mbgl::Map& NativeMapView::getMap() {
     return *map;
 }
 
+void NativeMapView::triggerRepaint(JNIEnv&) {
+    assert(map);
+    map->triggerRepaint();
+}
+
 // Static methods //
 
 void NativeMapView::registerNative(jni::JNIEnv& env) {
@@ -1248,7 +1255,8 @@ void NativeMapView::registerNative(jni::JNIEnv& env) {
         METHOD(&NativeMapView::setPrefetchTiles, "nativeSetPrefetchTiles"),
         METHOD(&NativeMapView::getPrefetchTiles, "nativeGetPrefetchTiles"),
         METHOD(&NativeMapView::setPrefetchZoomDelta, "nativeSetPrefetchZoomDelta"),
-        METHOD(&NativeMapView::getPrefetchZoomDelta, "nativeGetPrefetchZoomDelta"));
+        METHOD(&NativeMapView::getPrefetchZoomDelta, "nativeGetPrefetchZoomDelta"),
+        METHOD(&NativeMapView::triggerRepaint, "nativeTriggerRepaint"));
 }
 
 } // namespace android
diff --git a/platform/android/src/native_map_view.hpp b/platform/android/src/native_map_view.hpp
index ccd62e0b45..be632e242d 100644
--- a/platform/android/src/native_map_view.hpp
+++ b/platform/android/src/native_map_view.hpp
@@ -253,6 +253,8 @@ public:
 
     mbgl::Map& getMap();
 
+    void triggerRepaint(JNIEnv&);
+
 private:
     std::unique_ptr<AndroidRendererFrontend> rendererFrontend;
 
diff --git a/platform/android/src/snapshotter/map_snapshotter.cpp b/platform/android/src/snapshotter/map_snapshotter.cpp
index 852e1f6adb..5bccbd1ba8 100644
--- a/platform/android/src/snapshotter/map_snapshotter.cpp
+++ b/platform/android/src/snapshotter/map_snapshotter.cpp
@@ -1,10 +1,10 @@
 #include "map_snapshotter.hpp"
 
+#include <mbgl/actor/scheduler.hpp>
 #include <mbgl/renderer/renderer.hpp>
 #include <mbgl/style/style.hpp>
 #include <mbgl/util/logging.hpp>
 #include <mbgl/util/string.hpp>
-#include <mbgl/actor/scheduler.hpp>
 
 #include "../attach_env.hpp"
 #include "map_snapshot.hpp"
@@ -33,6 +33,8 @@ MapSnapshotter::MapSnapshotter(jni::JNIEnv& _env,
         return;
     }
 
+    weakScheduler = mbgl::Scheduler::GetCurrent()->makeWeakPtr();
+
     jFileSource = FileSource::getNativePeer(_env, _jFileSource);
     auto size = mbgl::Size { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
 
@@ -43,7 +45,7 @@ MapSnapshotter::MapSnapshotter(jni::JNIEnv& _env,
         size,
         pixelRatio,
         mbgl::android::FileSource::getSharedResourceOptions(_env, _jFileSource),
-        mbgl::MapSnapshotterObserver::nullObserver(),
+        *this,
         _localIdeographFontFamily ? jni::Make<std::string>(_env, _localIdeographFontFamily) : optional<std::string>{});
 
     if (position) {
@@ -61,7 +63,17 @@ MapSnapshotter::MapSnapshotter(jni::JNIEnv& _env,
     }
 }
 
-MapSnapshotter::~MapSnapshotter() = default;
+MapSnapshotter::~MapSnapshotter() {
+    auto guard = weakScheduler.lock();
+    if (weakScheduler && weakScheduler.get() != mbgl::Scheduler::GetCurrent()) {
+        snapshotter->cancel();
+        weakScheduler->schedule([ptr = snapshotter.release()]() mutable {
+            if (ptr) {
+                delete ptr;
+            }
+        });
+    }
+}
 
 void MapSnapshotter::start(JNIEnv& env) {
     MBGL_VERIFY_THREAD(tid);
@@ -126,7 +138,6 @@ void MapSnapshotter::setRegion(JNIEnv& env, const jni::Object<LatLngBounds>& reg
     snapshotter->setRegion(LatLngBounds::getLatLngBounds(env, region));
 }
 
-
 // Private methods //
 
 void MapSnapshotter::activateFilesource(JNIEnv& env) {
@@ -143,6 +154,134 @@ void MapSnapshotter::deactivateFilesource(JNIEnv& env) {
     }
 }
 
+void MapSnapshotter::onDidFailLoadingStyle(const std::string& error) {
+    MBGL_VERIFY_THREAD(tid);
+    android::UniqueEnv _env = android::AttachEnv();
+    static auto& javaClass = jni::Class<MapSnapshotter>::Singleton(*_env);
+    static auto onDidFailLoadingStyle = javaClass.GetMethod<void(jni::String)>(*_env, "onDidFailLoadingStyle");
+    auto weakReference = javaPeer.get(*_env);
+    if (weakReference) {
+        weakReference.Call(*_env, onDidFailLoadingStyle, jni::Make<jni::String>(*_env, error));
+    }
+}
+
+void MapSnapshotter::onDidFinishLoadingStyle() {
+    MBGL_VERIFY_THREAD(tid);
+    android::UniqueEnv _env = android::AttachEnv();
+
+    static auto& javaClass = jni::Class<MapSnapshotter>::Singleton(*_env);
+    static auto onDidFinishLoadingStyle = javaClass.GetMethod<void()>(*_env, "onDidFinishLoadingStyle");
+    auto weakReference = javaPeer.get(*_env);
+    if (weakReference) {
+        weakReference.Call(*_env, onDidFinishLoadingStyle);
+    }
+}
+
+void MapSnapshotter::onStyleImageMissing(const std::string& imageName) {
+    MBGL_VERIFY_THREAD(tid);
+    android::UniqueEnv _env = android::AttachEnv();
+    static auto& javaClass = jni::Class<MapSnapshotter>::Singleton(*_env);
+    static auto onStyleImageMissing = javaClass.GetMethod<void(jni::String)>(*_env, "onStyleImageMissing");
+    auto weakReference = javaPeer.get(*_env);
+    if (weakReference) {
+        weakReference.Call(*_env, onStyleImageMissing, jni::Make<jni::String>(*_env, imageName));
+    }
+}
+
+void MapSnapshotter::addLayerAt(JNIEnv& env, jlong nativeLayerPtr, jni::jint index) {
+    assert(nativeLayerPtr != 0);
+    const auto layers = snapshotter->getStyle().getLayers();
+    auto* layer = reinterpret_cast<Layer*>(nativeLayerPtr);
+    // Check index
+    const int numLayers = layers.size() - 1;
+    if (index > numLayers || index < 0) {
+        Log::Error(Event::JNI, "Index out of range: %i", index);
+        jni::ThrowNew(env,
+                      jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"),
+                      std::string("Invalid index").c_str());
+    }
+    // Insert it below the current at that index
+    try {
+        layer->addToStyle(snapshotter->getStyle(), layers.at(index)->getID());
+    } catch (const std::runtime_error& error) {
+        jni::ThrowNew(
+            env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"), error.what());
+    }
+}
+
+void MapSnapshotter::addLayerBelow(JNIEnv& env, jlong nativeLayerPtr, const jni::String& below) {
+    assert(nativeLayerPtr != 0);
+
+    auto* layer = reinterpret_cast<Layer*>(nativeLayerPtr);
+    try {
+        layer->addToStyle(
+            snapshotter->getStyle(),
+            below ? mbgl::optional<std::string>(jni::Make<std::string>(env, below)) : mbgl::optional<std::string>());
+    } catch (const std::runtime_error& error) {
+        jni::ThrowNew(
+            env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"), error.what());
+    }
+}
+
+void MapSnapshotter::addLayerAbove(JNIEnv& env, jlong nativeLayerPtr, const jni::String& above) {
+    assert(nativeLayerPtr != 0);
+    auto* newLayer = reinterpret_cast<Layer*>(nativeLayerPtr);
+
+    // Find the sibling
+    const auto snapshotterLayers = snapshotter->getStyle().getLayers();
+    auto siblingId = jni::Make<std::string>(env, above);
+
+    size_t index = 0;
+    for (auto* snapshotterLayer : snapshotterLayers) {
+        ++index;
+        if (snapshotterLayer->getID() == siblingId) {
+            break;
+        }
+    }
+
+    // Check if we found a sibling to place before
+    mbgl::optional<std::string> before;
+    if (index > snapshotterLayers.size()) {
+        // Not found
+        jni::ThrowNew(env,
+                      jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"),
+                      std::string("Could not find layer: ").append(siblingId).c_str());
+    } else if (index < snapshotterLayers.size()) {
+        // Place before the sibling
+        before = {snapshotterLayers.at(index)->getID()};
+    }
+
+    // Add the layer
+    try {
+        newLayer->addToStyle(snapshotter->getStyle(), before);
+    } catch (const std::runtime_error& error) {
+        jni::ThrowNew(
+            env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"), error.what());
+    }
+}
+
+void MapSnapshotter::addSource(JNIEnv& env, const jni::Object<Source>& obj, jlong sourcePtr) {
+    assert(sourcePtr != 0);
+
+    auto* source = reinterpret_cast<Source*>(sourcePtr);
+    try {
+        source->addToStyle(env, obj, snapshotter->getStyle());
+    } catch (const std::runtime_error& error) {
+        jni::ThrowNew(
+            env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/sources/CannotAddSourceException"), error.what());
+    }
+}
+
+void MapSnapshotter::addImages(JNIEnv& env, const jni::Array<jni::Object<mbgl::android::Image>>& jimages) {
+    jni::NullCheck(env, &jimages);
+    std::size_t len = jimages.Length(env);
+
+    for (std::size_t i = 0; i < len; ++i) {
+        auto image = mbgl::android::Image::getImage(env, jimages.Get(env, i));
+        snapshotter->getStyle().addImage(std::make_unique<mbgl::style::Image>(image));
+    }
+}
+
 // Static methods //
 
 void MapSnapshotter::registerNative(jni::JNIEnv& env) {
@@ -152,18 +291,35 @@ void MapSnapshotter::registerNative(jni::JNIEnv& env) {
 #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
     // Register the peer
-    jni::RegisterNativePeer<MapSnapshotter>(env, javaClass, "nativePtr",
-                                            jni::MakePeer<MapSnapshotter, const jni::Object<MapSnapshotter>&, const jni::Object<FileSource>&, jni::jfloat, jni::jint, jni::jint, const jni::String&, const jni::String&, const jni::Object<LatLngBounds>&, const jni::Object<CameraPosition>&, jni::jboolean, const jni::String&>,
-                                           "nativeInitialize",
-                                           "finalize",
+    jni::RegisterNativePeer<MapSnapshotter>(env,
+                                            javaClass,
+                                            "nativePtr",
+                                            jni::MakePeer<MapSnapshotter,
+                                                          const jni::Object<MapSnapshotter>&,
+                                                          const jni::Object<FileSource>&,
+                                                          jni::jfloat,
+                                                          jni::jint,
+                                                          jni::jint,
+                                                          const jni::String&,
+                                                          const jni::String&,
+                                                          const jni::Object<LatLngBounds>&,
+                                                          const jni::Object<CameraPosition>&,
+                                                          jni::jboolean,
+                                                          const jni::String&>,
+                                            "nativeInitialize",
+                                            "finalize",
                                             METHOD(&MapSnapshotter::setStyleUrl, "setStyleUrl"),
+                                            METHOD(&MapSnapshotter::addLayerAt, "nativeAddLayerAt"),
+                                            METHOD(&MapSnapshotter::addLayerBelow, "nativeAddLayerBelow"),
+                                            METHOD(&MapSnapshotter::addLayerAbove, "nativeAddLayerAbove"),
+                                            METHOD(&MapSnapshotter::addSource, "nativeAddSource"),
+                                            METHOD(&MapSnapshotter::addImages, "nativeAddImages"),
                                             METHOD(&MapSnapshotter::setStyleJson, "setStyleJson"),
                                             METHOD(&MapSnapshotter::setSize, "setSize"),
                                             METHOD(&MapSnapshotter::setCameraPosition, "setCameraPosition"),
                                             METHOD(&MapSnapshotter::setRegion, "setRegion"),
                                             METHOD(&MapSnapshotter::start, "nativeStart"),
-                                            METHOD(&MapSnapshotter::cancel, "nativeCancel")
-    );
+                                            METHOD(&MapSnapshotter::cancel, "nativeCancel"));
 }
 
 } // namespace android
diff --git a/platform/android/src/snapshotter/map_snapshotter.hpp b/platform/android/src/snapshotter/map_snapshotter.hpp
index 641a0e60f8..c7a9ce14ad 100644
--- a/platform/android/src/snapshotter/map_snapshotter.hpp
+++ b/platform/android/src/snapshotter/map_snapshotter.hpp
@@ -1,20 +1,23 @@
 #pragma once
 
+#include <jni/jni.hpp>
+#include <mapbox/std/weak.hpp>
 #include <mbgl/map/map_snapshotter.hpp>
 #include <mbgl/util/util.hpp>
 
+#include <memory>
+
 #include "../file_source.hpp"
 #include "../geometry/lat_lng_bounds.hpp"
 #include "../map/camera_position.hpp"
-
-#include <jni/jni.hpp>
-
-#include <memory>
+#include "../map/image.hpp"
+#include "../style/layers/layer.hpp"
+#include "../style/sources/source.hpp"
 
 namespace mbgl {
 namespace android {
 
-class MapSnapshotter {
+class MapSnapshotter final : public mbgl::MapSnapshotterObserver {
 public:
 
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/snapshotter/MapSnapshotter"; };
@@ -34,7 +37,7 @@ public:
                    jni::jboolean showLogo,
                    const jni::String& localIdeographFontFamily);
 
-    ~MapSnapshotter();
+    virtual ~MapSnapshotter() override;
 
     void setStyleUrl(JNIEnv&, const jni::String& styleURL);
 
@@ -50,6 +53,17 @@ public:
 
     void cancel(JNIEnv&);
 
+    void addLayerAt(JNIEnv&, jlong, jni::jint);
+    void addLayerBelow(JNIEnv&, jlong, const jni::String&);
+    void addLayerAbove(JNIEnv&, jlong, const jni::String&);
+    void addSource(JNIEnv&, const jni::Object<Source>&, jlong nativePtr);
+    void addImages(JNIEnv&, const jni::Array<jni::Object<mbgl::android::Image>>&);
+
+    // MapSnapshotterObserver overrides
+    void onDidFailLoadingStyle(const std::string&) override;
+    void onDidFinishLoadingStyle() override;
+    void onStyleImageMissing(const std::string&) override;
+
 private:
     MBGL_STORE_THREAD(tid);
 
@@ -59,12 +73,12 @@ private:
     float pixelRatio;
     bool showLogo;
 
-    std::unique_ptr<mbgl::MapSnapshotter> snapshotter;
-
     FileSource *jFileSource;
     void activateFilesource(JNIEnv&);
     void deactivateFilesource(JNIEnv&);
     bool activatedFilesource = false;
+    mapbox::base::WeakPtr<mbgl::Scheduler> weakScheduler;
+    std::unique_ptr<mbgl::MapSnapshotter> snapshotter;
 };
 
 } // namespace android
diff --git a/platform/android/src/style/layers/background_layer.cpp b/platform/android/src/style/layers/background_layer.cpp
index e28fd0798b..3eae30677f 100644
--- a/platform/android/src/style/layers/background_layer.cpp
+++ b/platform/android/src/style/layers/background_layer.cpp
@@ -26,16 +26,13 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    BackgroundLayer::BackgroundLayer(mbgl::Map& map, mbgl::style::BackgroundLayer& coreLayer)
-        : Layer(map, coreLayer) {
-    }
+    BackgroundLayer::BackgroundLayer(mbgl::style::BackgroundLayer& coreLayer) : Layer(coreLayer) {}
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    BackgroundLayer::BackgroundLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::BackgroundLayer> coreLayer)
-        : Layer(map, std::move(coreLayer)) {
-    }
+    BackgroundLayer::BackgroundLayer(std::unique_ptr<mbgl::style::BackgroundLayer> coreLayer)
+        : Layer(std::move(coreLayer)) {}
 
     BackgroundLayer::~BackgroundLayer() = default;
 
@@ -108,14 +105,18 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> BackgroundJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, toBackgroundLayer(layer)));
+        return createJavaPeer(env, new BackgroundLayer(toBackgroundLayer(layer)));
     }
 
-    jni::Local<jni::Object<Layer>> BackgroundJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, 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) {
@@ -126,7 +127,9 @@ namespace android {
 
         // Register the peer
         jni::RegisterNativePeer<BackgroundLayer>(
-            env, javaClass, "nativePtr",
+            env,
+            javaClass,
+            "nativePtr",
             jni::MakePeer<BackgroundLayer, jni::String&>,
             "initialize",
             "finalize",
diff --git a/platform/android/src/style/layers/background_layer.hpp b/platform/android/src/style/layers/background_layer.hpp
index 654031c6f4..e402dc021c 100644
--- a/platform/android/src/style/layers/background_layer.hpp
+++ b/platform/android/src/style/layers/background_layer.hpp
@@ -18,9 +18,9 @@ public:
 
     BackgroundLayer(jni::JNIEnv&, jni::String&);
 
-    BackgroundLayer(mbgl::Map&, mbgl::style::BackgroundLayer&);
+    BackgroundLayer(mbgl::style::BackgroundLayer&);
 
-    BackgroundLayer(mbgl::Map&, std::unique_ptr<mbgl::style::BackgroundLayer>);
+    BackgroundLayer(std::unique_ptr<mbgl::style::BackgroundLayer>);
 
     ~BackgroundLayer();
 
@@ -45,8 +45,8 @@ 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;
+    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;
 
diff --git a/platform/android/src/style/layers/circle_layer.cpp b/platform/android/src/style/layers/circle_layer.cpp
index f460031dcd..a7fae5e233 100644
--- a/platform/android/src/style/layers/circle_layer.cpp
+++ b/platform/android/src/style/layers/circle_layer.cpp
@@ -26,16 +26,12 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    CircleLayer::CircleLayer(mbgl::Map& map, mbgl::style::CircleLayer& coreLayer)
-        : Layer(map, coreLayer) {
-    }
+    CircleLayer::CircleLayer(mbgl::style::CircleLayer& coreLayer) : Layer(coreLayer) {}
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    CircleLayer::CircleLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::CircleLayer> coreLayer)
-        : Layer(map, std::move(coreLayer)) {
-    }
+    CircleLayer::CircleLayer(std::unique_ptr<mbgl::style::CircleLayer> coreLayer) : Layer(std::move(coreLayer)) {}
 
     CircleLayer::~CircleLayer() = default;
 
@@ -213,14 +209,18 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> CircleJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, toCircleLayer(layer)));
+        return createJavaPeer(env, new CircleLayer(toCircleLayer(layer)));
     }
 
-    jni::Local<jni::Object<Layer>> CircleJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, 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) {
@@ -231,7 +231,9 @@ namespace android {
 
         // Register the peer
         jni::RegisterNativePeer<CircleLayer>(
-            env, javaClass, "nativePtr",
+            env,
+            javaClass,
+            "nativePtr",
             jni::MakePeer<CircleLayer, jni::String&, jni::String&>,
             "initialize",
             "finalize",
diff --git a/platform/android/src/style/layers/circle_layer.hpp b/platform/android/src/style/layers/circle_layer.hpp
index 191b3924ff..40dca91e2e 100644
--- a/platform/android/src/style/layers/circle_layer.hpp
+++ b/platform/android/src/style/layers/circle_layer.hpp
@@ -18,9 +18,9 @@ public:
 
     CircleLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
-    CircleLayer(mbgl::Map&, mbgl::style::CircleLayer&);
+    CircleLayer(mbgl::style::CircleLayer&);
 
-    CircleLayer(mbgl::Map&, std::unique_ptr<mbgl::style::CircleLayer>);
+    CircleLayer(std::unique_ptr<mbgl::style::CircleLayer>);
 
     ~CircleLayer();
 
@@ -71,8 +71,8 @@ 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;
+    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;
 
diff --git a/platform/android/src/style/layers/custom_layer.cpp b/platform/android/src/style/layers/custom_layer.cpp
index 3f44aa8505..5a8b239a8d 100644
--- a/platform/android/src/style/layers/custom_layer.cpp
+++ b/platform/android/src/style/layers/custom_layer.cpp
@@ -14,25 +14,12 @@ namespace android {
                 ) {
     }
 
-    CustomLayer::CustomLayer(mbgl::Map& map, mbgl::style::CustomLayer& coreLayer)
-        : Layer(map, coreLayer) {
-    }
+    CustomLayer::CustomLayer(mbgl::style::CustomLayer& coreLayer) : Layer(coreLayer) {}
 
-    CustomLayer::CustomLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::CustomLayer> coreLayer)
-        : Layer(map, std::move(coreLayer)) {
-    }
+    CustomLayer::CustomLayer(std::unique_ptr<mbgl::style::CustomLayer> coreLayer) : Layer(std::move(coreLayer)) {}
 
     CustomLayer::~CustomLayer() = default;
 
-    void CustomLayer::update(jni::JNIEnv&) {
-        Log::Debug(mbgl::Event::JNI, "Updating map");
-        if (map) {
-            map->triggerRepaint();
-        } else {
-            Log::Error(mbgl::Event::JNI, "No map reference, cannot update");
-        }
-    }
-
     namespace {
         jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
             static auto& javaClass = jni::Class<CustomLayer>::Singleton(env);
@@ -43,12 +30,16 @@ namespace android {
 
     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::style::Layer& layer) {
+        return createJavaPeer(env, new CustomLayer(static_cast<mbgl::style::CustomLayer&>(layer)));
     }
 
-    jni::Local<jni::Object<Layer>> CustomJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::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()))));
+    jni::Local<jni::Object<Layer>> CustomJavaLayerPeerFactory::createJavaLayerPeer(
+        jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+        return createJavaPeer(env,
+                              new CustomLayer(std::unique_ptr<mbgl::style::CustomLayer>(
+                                  static_cast<mbgl::style::CustomLayer*>(layer.release()))));
     }
 
     void CustomJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
@@ -58,12 +49,12 @@ namespace android {
         #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
         // Register the peer
-        jni::RegisterNativePeer<CustomLayer>(
-            env, javaClass, "nativePtr",
-            jni::MakePeer<CustomLayer, const jni::String&, jni::jlong>,
-            "initialize",
-            "finalize",
-            METHOD(&CustomLayer::update, "nativeUpdate"));
+        jni::RegisterNativePeer<CustomLayer>(env,
+                                             javaClass,
+                                             "nativePtr",
+                                             jni::MakePeer<CustomLayer, const jni::String&, jni::jlong>,
+                                             "initialize",
+                                             "finalize");
     }
 
 } // namespace android
diff --git a/platform/android/src/style/layers/custom_layer.hpp b/platform/android/src/style/layers/custom_layer.hpp
index dc328a2137..3856ea73ae 100644
--- a/platform/android/src/style/layers/custom_layer.hpp
+++ b/platform/android/src/style/layers/custom_layer.hpp
@@ -16,14 +16,11 @@ public:
     static void registerNative(jni::JNIEnv&);
 
     CustomLayer(jni::JNIEnv&, const jni::String&, jni::jlong);
-    CustomLayer(mbgl::Map&, mbgl::style::CustomLayer&);
-    CustomLayer(mbgl::Map&, std::unique_ptr<mbgl::style::CustomLayer>);
+    CustomLayer(mbgl::style::CustomLayer&);
+    CustomLayer(std::unique_ptr<mbgl::style::CustomLayer>);
     ~CustomLayer();
 
-    void update(jni::JNIEnv&);
-
     jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
-
 }; // class CustomLayer
 
 class CustomJavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::CustomLayerFactory {
@@ -31,8 +28,8 @@ 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;
+    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;
 
diff --git a/platform/android/src/style/layers/fill_extrusion_layer.cpp b/platform/android/src/style/layers/fill_extrusion_layer.cpp
index ddfbd71544..55c3d20282 100644
--- a/platform/android/src/style/layers/fill_extrusion_layer.cpp
+++ b/platform/android/src/style/layers/fill_extrusion_layer.cpp
@@ -26,16 +26,13 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    FillExtrusionLayer::FillExtrusionLayer(mbgl::Map& map, mbgl::style::FillExtrusionLayer& coreLayer)
-        : Layer(map, coreLayer) {
-    }
+    FillExtrusionLayer::FillExtrusionLayer(mbgl::style::FillExtrusionLayer& coreLayer) : Layer(coreLayer) {}
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    FillExtrusionLayer::FillExtrusionLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::FillExtrusionLayer> coreLayer)
-        : Layer(map, std::move(coreLayer)) {
-    }
+    FillExtrusionLayer::FillExtrusionLayer(std::unique_ptr<mbgl::style::FillExtrusionLayer> coreLayer)
+        : Layer(std::move(coreLayer)) {}
 
     FillExtrusionLayer::~FillExtrusionLayer() = default;
 
@@ -172,14 +169,18 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> FillExtrusionJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, toFillExtrusionLayer(layer)));
+        return createJavaPeer(env, new FillExtrusionLayer(toFillExtrusionLayer(layer)));
     }
 
-    jni::Local<jni::Object<Layer>> FillExtrusionJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, 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) {
@@ -190,7 +191,9 @@ namespace android {
 
         // Register the peer
         jni::RegisterNativePeer<FillExtrusionLayer>(
-            env, javaClass, "nativePtr",
+            env,
+            javaClass,
+            "nativePtr",
             jni::MakePeer<FillExtrusionLayer, jni::String&, jni::String&>,
             "initialize",
             "finalize",
@@ -200,8 +203,10 @@ 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_extrusion_layer.hpp b/platform/android/src/style/layers/fill_extrusion_layer.hpp
index 15dad67b01..6f0a24131c 100644
--- a/platform/android/src/style/layers/fill_extrusion_layer.hpp
+++ b/platform/android/src/style/layers/fill_extrusion_layer.hpp
@@ -18,9 +18,9 @@ public:
 
     FillExtrusionLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
-    FillExtrusionLayer(mbgl::Map&, mbgl::style::FillExtrusionLayer&);
+    FillExtrusionLayer(mbgl::style::FillExtrusionLayer&);
 
-    FillExtrusionLayer(mbgl::Map&, std::unique_ptr<mbgl::style::FillExtrusionLayer>);
+    FillExtrusionLayer(std::unique_ptr<mbgl::style::FillExtrusionLayer>);
 
     ~FillExtrusionLayer();
 
@@ -61,8 +61,8 @@ 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;
+    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;
 
diff --git a/platform/android/src/style/layers/fill_layer.cpp b/platform/android/src/style/layers/fill_layer.cpp
index 3679688efc..6a646fdc7d 100644
--- a/platform/android/src/style/layers/fill_layer.cpp
+++ b/platform/android/src/style/layers/fill_layer.cpp
@@ -26,16 +26,12 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    FillLayer::FillLayer(mbgl::Map& map, mbgl::style::FillLayer& coreLayer)
-        : Layer(map, coreLayer) {
-    }
+    FillLayer::FillLayer(mbgl::style::FillLayer& coreLayer) : Layer(coreLayer) {}
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    FillLayer::FillLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::FillLayer> coreLayer)
-        : Layer(map, std::move(coreLayer)) {
-    }
+    FillLayer::FillLayer(std::unique_ptr<mbgl::style::FillLayer> coreLayer) : Layer(std::move(coreLayer)) {}
 
     FillLayer::~FillLayer() = default;
 
@@ -159,14 +155,18 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> FillJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, toFillLayer(layer)));
+        return createJavaPeer(env, new FillLayer(toFillLayer(layer)));
     }
 
-    jni::Local<jni::Object<Layer>> FillJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, 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/fill_layer.hpp b/platform/android/src/style/layers/fill_layer.hpp
index e6471643ca..807b939a71 100644
--- a/platform/android/src/style/layers/fill_layer.hpp
+++ b/platform/android/src/style/layers/fill_layer.hpp
@@ -18,9 +18,9 @@ public:
 
     FillLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
-    FillLayer(mbgl::Map&, mbgl::style::FillLayer&);
+    FillLayer(mbgl::style::FillLayer&);
 
-    FillLayer(mbgl::Map&, std::unique_ptr<mbgl::style::FillLayer>);
+    FillLayer(std::unique_ptr<mbgl::style::FillLayer>);
 
     ~FillLayer();
 
@@ -59,8 +59,8 @@ 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;
+    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;
 
diff --git a/platform/android/src/style/layers/heatmap_layer.cpp b/platform/android/src/style/layers/heatmap_layer.cpp
index 509ab5d707..dad3d25e6c 100644
--- a/platform/android/src/style/layers/heatmap_layer.cpp
+++ b/platform/android/src/style/layers/heatmap_layer.cpp
@@ -26,16 +26,12 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    HeatmapLayer::HeatmapLayer(mbgl::Map& map, mbgl::style::HeatmapLayer& coreLayer)
-        : Layer(map, coreLayer) {
-    }
+    HeatmapLayer::HeatmapLayer(mbgl::style::HeatmapLayer& coreLayer) : Layer(coreLayer) {}
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    HeatmapLayer::HeatmapLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::HeatmapLayer> coreLayer)
-        : Layer(map, std::move(coreLayer)) {
-    }
+    HeatmapLayer::HeatmapLayer(std::unique_ptr<mbgl::style::HeatmapLayer> coreLayer) : Layer(std::move(coreLayer)) {}
 
     HeatmapLayer::~HeatmapLayer() = default;
 
@@ -122,14 +118,18 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> HeatmapJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, toHeatmapLayer(layer)));
+        return createJavaPeer(env, new HeatmapLayer(toHeatmapLayer(layer)));
     }
 
-    jni::Local<jni::Object<Layer>> HeatmapJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, 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) {
@@ -140,7 +140,9 @@ namespace android {
 
         // Register the peer
         jni::RegisterNativePeer<HeatmapLayer>(
-            env, javaClass, "nativePtr",
+            env,
+            javaClass,
+            "nativePtr",
             jni::MakePeer<HeatmapLayer, jni::String&, jni::String&>,
             "initialize",
             "finalize",
diff --git a/platform/android/src/style/layers/heatmap_layer.hpp b/platform/android/src/style/layers/heatmap_layer.hpp
index 9e3db0c89a..f56e3eb4a9 100644
--- a/platform/android/src/style/layers/heatmap_layer.hpp
+++ b/platform/android/src/style/layers/heatmap_layer.hpp
@@ -18,9 +18,9 @@ public:
 
     HeatmapLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
-    HeatmapLayer(mbgl::Map&, mbgl::style::HeatmapLayer&);
+    HeatmapLayer(mbgl::style::HeatmapLayer&);
 
-    HeatmapLayer(mbgl::Map&, std::unique_ptr<mbgl::style::HeatmapLayer>);
+    HeatmapLayer(std::unique_ptr<mbgl::style::HeatmapLayer>);
 
     ~HeatmapLayer();
 
@@ -49,8 +49,8 @@ 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;
+    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;
 
diff --git a/platform/android/src/style/layers/hillshade_layer.cpp b/platform/android/src/style/layers/hillshade_layer.cpp
index bc25f666a0..1f5fe1912f 100644
--- a/platform/android/src/style/layers/hillshade_layer.cpp
+++ b/platform/android/src/style/layers/hillshade_layer.cpp
@@ -26,16 +26,13 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    HillshadeLayer::HillshadeLayer(mbgl::Map& map, mbgl::style::HillshadeLayer& coreLayer)
-        : Layer(map, coreLayer) {
-    }
+    HillshadeLayer::HillshadeLayer(mbgl::style::HillshadeLayer& coreLayer) : Layer(coreLayer) {}
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    HillshadeLayer::HillshadeLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::HillshadeLayer> coreLayer)
-        : Layer(map, std::move(coreLayer)) {
-    }
+    HillshadeLayer::HillshadeLayer(std::unique_ptr<mbgl::style::HillshadeLayer> coreLayer)
+        : Layer(std::move(coreLayer)) {}
 
     HillshadeLayer::~HillshadeLayer() = default;
 
@@ -136,14 +133,18 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> HillshadeJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, toHillshadeLayer(layer)));
+        return createJavaPeer(env, new HillshadeLayer(toHillshadeLayer(layer)));
     }
 
-    jni::Local<jni::Object<Layer>> HillshadeJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, 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) {
@@ -154,7 +155,9 @@ namespace android {
 
         // Register the peer
         jni::RegisterNativePeer<HillshadeLayer>(
-            env, javaClass, "nativePtr",
+            env,
+            javaClass,
+            "nativePtr",
             jni::MakePeer<HillshadeLayer, jni::String&, jni::String&>,
             "initialize",
             "finalize",
diff --git a/platform/android/src/style/layers/hillshade_layer.hpp b/platform/android/src/style/layers/hillshade_layer.hpp
index 2f4ea30c22..bc210a9987 100644
--- a/platform/android/src/style/layers/hillshade_layer.hpp
+++ b/platform/android/src/style/layers/hillshade_layer.hpp
@@ -18,9 +18,9 @@ public:
 
     HillshadeLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
-    HillshadeLayer(mbgl::Map&, mbgl::style::HillshadeLayer&);
+    HillshadeLayer(mbgl::style::HillshadeLayer&);
 
-    HillshadeLayer(mbgl::Map&, std::unique_ptr<mbgl::style::HillshadeLayer>);
+    HillshadeLayer(std::unique_ptr<mbgl::style::HillshadeLayer>);
 
     ~HillshadeLayer();
 
@@ -53,8 +53,8 @@ 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;
+    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;
 
diff --git a/platform/android/src/style/layers/layer.cpp b/platform/android/src/style/layers/layer.cpp
index b90d670a4b..bc87a9d9ba 100644
--- a/platform/android/src/style/layers/layer.cpp
+++ b/platform/android/src/style/layers/layer.cpp
@@ -45,33 +45,19 @@ namespace android {
     /**
      * Takes a non-owning reference. For lookup methods
      */
-    Layer::Layer(mbgl::Map& coreMap, mbgl::style::Layer& coreLayer) : layer(coreLayer) , map(&coreMap) {
-    }
-
-    /**
-     * Takes a owning reference. Ownership is transfered to this peer, eg after removing
-     * from the map
-     */
-    Layer::Layer(mbgl::Map& coreMap, std::unique_ptr<mbgl::style::Layer> coreLayer)
-        : ownedLayer(std::move(coreLayer))
-        , layer(*ownedLayer)
-        , map(&coreMap) {
-    }
+    Layer::Layer(mbgl::style::Layer& coreLayer) : layer(coreLayer) {}
 
     Layer::~Layer() {
     }
 
-    void Layer::addToMap(mbgl::Map& _map, mbgl::optional<std::string> before) {
+    void Layer::addToStyle(mbgl::style::Style& style, mbgl::optional<std::string> before) {
         // Check to see if we own the layer first
         if (!ownedLayer) {
             throw std::runtime_error("Cannot add layer twice");
         }
 
         // Add layer to map
-        _map.getStyle().addLayer(releaseCoreLayer(), before);
-
-        // Save pointer to the map
-        this->map = &_map;
+        style.addLayer(releaseCoreLayer(), before);
     }
 
     void Layer::setLayer(std::unique_ptr<mbgl::style::Layer> sourceLayer) {
diff --git a/platform/android/src/style/layers/layer.cpp.ejs b/platform/android/src/style/layers/layer.cpp.ejs
index e98ee49ff6..5d241e9a3b 100644
--- a/platform/android/src/style/layers/layer.cpp.ejs
+++ b/platform/android/src/style/layers/layer.cpp.ejs
@@ -38,15 +38,15 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(mbgl::Map& map, mbgl::style::<%- camelize(type) %>Layer& coreLayer)
-        : Layer(map, coreLayer) {
+    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(mbgl::style::<%- camelize(type) %>Layer& coreLayer)
+        : Layer(coreLayer) {
     }
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(mbgl::Map& map, std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer> coreLayer)
-        : Layer(map, std::move(coreLayer)) {
+    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer> coreLayer)
+        : Layer(std::move(coreLayer)) {
     }
 
     <%- camelize(type) %>Layer::~<%- camelize(type) %>Layer() = default;
@@ -100,14 +100,14 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> <%- camelize(type) %>JavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& layer) {
+    jni::Local<jni::Object<Layer>> <%- camelize(type) %>JavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::style::Layer& layer) {
         assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
-        return createJavaPeer(env, new <%- camelize(type) %>Layer(map, to<%- camelize(type) %>Layer(layer)));
+        return createJavaPeer(env, new <%- camelize(type) %>Layer(to<%- camelize(type) %>Layer(layer)));
     }
 
-    jni::Local<jni::Object<Layer>> <%- camelize(type) %>JavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+    jni::Local<jni::Object<Layer>> <%- camelize(type) %>JavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
         assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
-        return createJavaPeer(env, new <%- camelize(type) %>Layer(map, std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer>(static_cast<mbgl::style::<%- camelize(type) %>Layer*>(layer.release()))));
+        return createJavaPeer(env, new <%- camelize(type) %>Layer(std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer>(static_cast<mbgl::style::<%- camelize(type) %>Layer*>(layer.release()))));
     }
 
     void <%- camelize(type) %>JavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
diff --git a/platform/android/src/style/layers/layer.hpp b/platform/android/src/style/layers/layer.hpp
index 5717852d0c..557990844c 100644
--- a/platform/android/src/style/layers/layer.hpp
+++ b/platform/android/src/style/layers/layer.hpp
@@ -1,11 +1,11 @@
 #pragma once
 
 #include <mbgl/layermanager/layer_factory.hpp>
-#include <mbgl/map/map.hpp>
 #include <mbgl/style/layer.hpp>
+#include <mbgl/style/style.hpp>
 #include "../../gson/json_array.hpp"
-#include "../value.hpp"
 #include "../../gson/json_element.hpp"
+#include "../value.hpp"
 
 #include <jni/jni.hpp>
 
@@ -27,7 +27,7 @@ public:
      */
     void setLayer(std::unique_ptr<mbgl::style::Layer>);
 
-    void addToMap(mbgl::Map&, mbgl::optional<std::string>);
+    void addToStyle(mbgl::style::Style&, mbgl::optional<std::string>);
 
     // Release the owned view and return it
     std::unique_ptr<mbgl::style::Layer> releaseCoreLayer();
@@ -68,16 +68,11 @@ protected:
     /*
      * Called when a non-owning peer object is created on the c++ side
      */
-    Layer(mbgl::Map&, mbgl::style::Layer&);
+    Layer(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>);
 
     // Owned layer is set when creating a new layer, before adding it to the map
@@ -85,9 +80,6 @@ protected:
 
     // Raw reference to the layer
     mbgl::style::Layer& layer;
-
-    // Map is set when the layer is retrieved or after adding to the map
-    mbgl::Map* map;
 };
 
 /**
@@ -99,12 +91,13 @@ public:
     /**
      * @brief Create a non-owning peer.
      */
-    virtual jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&) = 0;
+    virtual jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) = 0;
 
     /**
      * @brief Create an owning peer.
      */
-    virtual jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>) = 0;
+    virtual jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env,
+                                                               std::unique_ptr<mbgl::style::Layer>) = 0;
 
     /**
      * @brief Register peer methods.
diff --git a/platform/android/src/style/layers/layer.hpp.ejs b/platform/android/src/style/layers/layer.hpp.ejs
index 28e00b2731..eb8db0620d 100644
--- a/platform/android/src/style/layers/layer.hpp.ejs
+++ b/platform/android/src/style/layers/layer.hpp.ejs
@@ -26,9 +26,9 @@ public:
     <%- camelize(type) %>Layer(jni::JNIEnv&, jni::String&, jni::String&);
 <% } -%>
 
-    <%- camelize(type) %>Layer(mbgl::Map&, mbgl::style::<%- camelize(type) %>Layer&);
+    <%- camelize(type) %>Layer(mbgl::style::<%- camelize(type) %>Layer&);
 
-    <%- camelize(type) %>Layer(mbgl::Map&, std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer>);
+    <%- camelize(type) %>Layer(std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer>);
 
     ~<%- camelize(type) %>Layer();
 
@@ -49,8 +49,8 @@ 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;
+    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;
 
diff --git a/platform/android/src/style/layers/layer_manager.cpp b/platform/android/src/style/layers/layer_manager.cpp
index d0c54ee00f..2d4172a235 100644
--- a/platform/android/src/style/layers/layer_manager.cpp
+++ b/platform/android/src/style/layers/layer_manager.cpp
@@ -77,16 +77,17 @@ LayerManagerAndroid::LayerManagerAndroid() {
 
 LayerManagerAndroid::~LayerManagerAndroid() = default;
 
-jni::Local<jni::Object<Layer>> LayerManagerAndroid::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& layer) {
+jni::Local<jni::Object<Layer>> LayerManagerAndroid::createJavaLayerPeer(jni::JNIEnv& env, mbgl::style::Layer& layer) {
     if (JavaLayerPeerFactory* factory = getPeerFactory(layer.getTypeInfo())) {
-        return factory->createJavaLayerPeer(env, map, layer);
+        return factory->createJavaLayerPeer(env, layer);
     }
     return jni::Local<jni::Object<Layer>>();
 }
 
-jni::Local<jni::Object<Layer>> LayerManagerAndroid::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> layer) {
+jni::Local<jni::Object<Layer>> LayerManagerAndroid::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                        std::unique_ptr<mbgl::style::Layer> layer) {
     if (JavaLayerPeerFactory* factory = getPeerFactory(layer->getTypeInfo())) {
-        return factory->createJavaLayerPeer(env, map, std::move(layer));
+        return factory->createJavaLayerPeer(env, std::move(layer));
     }
     return jni::Local<jni::Object<Layer>>();
 }
diff --git a/platform/android/src/style/layers/layer_manager.hpp b/platform/android/src/style/layers/layer_manager.hpp
index 807ded1737..f7379f6de6 100644
--- a/platform/android/src/style/layers/layer_manager.hpp
+++ b/platform/android/src/style/layers/layer_manager.hpp
@@ -21,9 +21,9 @@ class LayerManagerAndroid final : public mbgl::LayerManager {
 public:
     ~LayerManagerAndroid() final;
     static LayerManagerAndroid* get() noexcept;
-    
-    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>);
+
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&);
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>);
 
     void registerNative(jni::JNIEnv&);
 
diff --git a/platform/android/src/style/layers/line_layer.cpp b/platform/android/src/style/layers/line_layer.cpp
index 1719c9ae59..89c6cb5323 100644
--- a/platform/android/src/style/layers/line_layer.cpp
+++ b/platform/android/src/style/layers/line_layer.cpp
@@ -26,16 +26,12 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    LineLayer::LineLayer(mbgl::Map& map, mbgl::style::LineLayer& coreLayer)
-        : Layer(map, coreLayer) {
-    }
+    LineLayer::LineLayer(mbgl::style::LineLayer& coreLayer) : Layer(coreLayer) {}
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    LineLayer::LineLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::LineLayer> coreLayer)
-        : Layer(map, std::move(coreLayer)) {
-    }
+    LineLayer::LineLayer(std::unique_ptr<mbgl::style::LineLayer> coreLayer) : Layer(std::move(coreLayer)) {}
 
     LineLayer::~LineLayer() = default;
 
@@ -251,14 +247,18 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> LineJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, toLineLayer(layer)));
+        return createJavaPeer(env, new LineLayer(toLineLayer(layer)));
     }
 
-    jni::Local<jni::Object<Layer>> LineJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, 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/line_layer.hpp b/platform/android/src/style/layers/line_layer.hpp
index 72a69f218e..25b270fbc6 100644
--- a/platform/android/src/style/layers/line_layer.hpp
+++ b/platform/android/src/style/layers/line_layer.hpp
@@ -18,9 +18,9 @@ public:
 
     LineLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
-    LineLayer(mbgl::Map&, mbgl::style::LineLayer&);
+    LineLayer(mbgl::style::LineLayer&);
 
-    LineLayer(mbgl::Map&, std::unique_ptr<mbgl::style::LineLayer>);
+    LineLayer(std::unique_ptr<mbgl::style::LineLayer>);
 
     ~LineLayer();
 
@@ -83,8 +83,8 @@ 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;
+    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;
 
diff --git a/platform/android/src/style/layers/raster_layer.cpp b/platform/android/src/style/layers/raster_layer.cpp
index b12267525f..d9cce949c2 100644
--- a/platform/android/src/style/layers/raster_layer.cpp
+++ b/platform/android/src/style/layers/raster_layer.cpp
@@ -26,16 +26,12 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    RasterLayer::RasterLayer(mbgl::Map& map, mbgl::style::RasterLayer& coreLayer)
-        : Layer(map, coreLayer) {
-    }
+    RasterLayer::RasterLayer(mbgl::style::RasterLayer& coreLayer) : Layer(coreLayer) {}
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    RasterLayer::RasterLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::RasterLayer> coreLayer)
-        : Layer(map, std::move(coreLayer)) {
-    }
+    RasterLayer::RasterLayer(std::unique_ptr<mbgl::style::RasterLayer> coreLayer) : Layer(std::move(coreLayer)) {}
 
     RasterLayer::~RasterLayer() = default;
 
@@ -172,14 +168,18 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> RasterJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, toRasterLayer(layer)));
+        return createJavaPeer(env, new RasterLayer(toRasterLayer(layer)));
     }
 
-    jni::Local<jni::Object<Layer>> RasterJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, 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) {
@@ -190,7 +190,9 @@ namespace android {
 
         // Register the peer
         jni::RegisterNativePeer<RasterLayer>(
-            env, javaClass, "nativePtr",
+            env,
+            javaClass,
+            "nativePtr",
             jni::MakePeer<RasterLayer, jni::String&, jni::String&>,
             "initialize",
             "finalize",
diff --git a/platform/android/src/style/layers/raster_layer.hpp b/platform/android/src/style/layers/raster_layer.hpp
index 53bee85e2b..bbda2e0c57 100644
--- a/platform/android/src/style/layers/raster_layer.hpp
+++ b/platform/android/src/style/layers/raster_layer.hpp
@@ -18,9 +18,9 @@ public:
 
     RasterLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
-    RasterLayer(mbgl::Map&, mbgl::style::RasterLayer&);
+    RasterLayer(mbgl::style::RasterLayer&);
 
-    RasterLayer(mbgl::Map&, std::unique_ptr<mbgl::style::RasterLayer>);
+    RasterLayer(std::unique_ptr<mbgl::style::RasterLayer>);
 
     ~RasterLayer();
 
@@ -61,8 +61,8 @@ 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;
+    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;
 
diff --git a/platform/android/src/style/layers/symbol_layer.cpp b/platform/android/src/style/layers/symbol_layer.cpp
index 53b35a9a13..f24fb35425 100644
--- a/platform/android/src/style/layers/symbol_layer.cpp
+++ b/platform/android/src/style/layers/symbol_layer.cpp
@@ -26,16 +26,12 @@ namespace android {
     /**
      * Creates a non-owning peer object (for layers currently attached to the map)
      */
-    SymbolLayer::SymbolLayer(mbgl::Map& map, mbgl::style::SymbolLayer& coreLayer)
-        : Layer(map, coreLayer) {
-    }
+    SymbolLayer::SymbolLayer(mbgl::style::SymbolLayer& coreLayer) : Layer(coreLayer) {}
 
     /**
      * Creates an owning peer object (for layers not attached to the map)
      */
-    SymbolLayer::SymbolLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::SymbolLayer> coreLayer)
-        : Layer(map, std::move(coreLayer)) {
-    }
+    SymbolLayer::SymbolLayer(std::unique_ptr<mbgl::style::SymbolLayer> coreLayer) : Layer(std::move(coreLayer)) {}
 
     SymbolLayer::~SymbolLayer() = default;
 
@@ -485,14 +481,18 @@ namespace android {
         }
     }  // namespace
 
-    jni::Local<jni::Object<Layer>> SymbolJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, toSymbolLayer(layer)));
+        return createJavaPeer(env, new SymbolLayer(toSymbolLayer(layer)));
     }
 
-    jni::Local<jni::Object<Layer>> SymbolJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, 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(map, 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) {
@@ -503,7 +503,9 @@ namespace android {
 
         // Register the peer
         jni::RegisterNativePeer<SymbolLayer>(
-            env, javaClass, "nativePtr",
+            env,
+            javaClass,
+            "nativePtr",
             jni::MakePeer<SymbolLayer, jni::String&, jni::String&>,
             "initialize",
             "finalize",
diff --git a/platform/android/src/style/layers/symbol_layer.hpp b/platform/android/src/style/layers/symbol_layer.hpp
index 9e494e678a..4898c830df 100644
--- a/platform/android/src/style/layers/symbol_layer.hpp
+++ b/platform/android/src/style/layers/symbol_layer.hpp
@@ -18,9 +18,9 @@ public:
 
     SymbolLayer(jni::JNIEnv&, jni::String&, jni::String&);
 
-    SymbolLayer(mbgl::Map&, mbgl::style::SymbolLayer&);
+    SymbolLayer(mbgl::style::SymbolLayer&);
 
-    SymbolLayer(mbgl::Map&, std::unique_ptr<mbgl::style::SymbolLayer>);
+    SymbolLayer(std::unique_ptr<mbgl::style::SymbolLayer>);
 
     ~SymbolLayer();
 
@@ -167,8 +167,8 @@ 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;
+    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;
 
diff --git a/platform/android/src/style/sources/source.cpp b/platform/android/src/style/sources/source.cpp
index fda0f0084c..f4040a5718 100644
--- a/platform/android/src/style/sources/source.cpp
+++ b/platform/android/src/style/sources/source.cpp
@@ -109,6 +109,21 @@ namespace android {
         return jni::Local<jni::Integer>(env, nullptr);
     }
 
+    void Source::addToStyle(JNIEnv& env, const jni::Object<Source>& obj, mbgl::style::Style& style) {
+        if (!ownedSource) {
+            throw std::runtime_error("Cannot add source twice");
+        }
+
+        // Add source to style and release ownership
+        style.addSource(std::move(ownedSource));
+
+        // Add peer to core source
+        source.peer = std::unique_ptr<Source>(this);
+
+        // Add strong reference to java source
+        javaPeer = jni::NewGlobal(env, obj);
+    }
+
     void Source::addToMap(JNIEnv& env, const jni::Object<Source>& obj, mbgl::Map& map, AndroidRendererFrontend& frontend) {
         // Check to see if we own the source first
         if (!ownedSource) {
diff --git a/platform/android/src/style/sources/source.hpp b/platform/android/src/style/sources/source.hpp
index 91e31ea8e2..a87972ce79 100644
--- a/platform/android/src/style/sources/source.hpp
+++ b/platform/android/src/style/sources/source.hpp
@@ -47,6 +47,8 @@ public:
 
     jni::Local<jni::Integer> getPrefetchZoomDelta(jni::JNIEnv&);
 
+    void addToStyle(JNIEnv& env, const jni::Object<Source>& obj, mbgl::style::Style& style);
+
 protected:
     // Set on newly created sources until added to the map.
     std::unique_ptr<mbgl::style::Source> ownedSource;