diff options
Diffstat (limited to 'platform/android/src/style/layers')
21 files changed, 298 insertions, 59 deletions
diff --git a/platform/android/src/style/layers/background_layer.cpp b/platform/android/src/style/layers/background_layer.cpp index 021ac947ad..9915f3894e 100644 --- a/platform/android/src/style/layers/background_layer.cpp +++ b/platform/android/src/style/layers/background_layer.cpp @@ -9,14 +9,27 @@ namespace mbgl { 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))) { } + /** + * 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) { } + /** + * 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() = default; // Property getters @@ -47,12 +60,12 @@ namespace android { } void BackgroundLayer::registerNative(jni::JNIEnv& env) { - //Lookup the class + // Lookup the class BackgroundLayer::javaClass = *jni::Class<BackgroundLayer>::Find(env).NewGlobalRef(env).release(); #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name) - //Register the peer + // Register the peer jni::RegisterNativePeer<BackgroundLayer>( env, BackgroundLayer::javaClass, "nativePtr", std::make_unique<BackgroundLayer, JNIEnv&, jni::String>, diff --git a/platform/android/src/style/layers/background_layer.hpp b/platform/android/src/style/layers/background_layer.hpp index bd62c024f4..2fdc948892 100644 --- a/platform/android/src/style/layers/background_layer.hpp +++ b/platform/android/src/style/layers/background_layer.hpp @@ -22,6 +22,8 @@ public: BackgroundLayer(mbgl::Map&, mbgl::style::BackgroundLayer&); + BackgroundLayer(mbgl::Map&, std::unique_ptr<mbgl::style::BackgroundLayer>); + ~BackgroundLayer(); // Property getters diff --git a/platform/android/src/style/layers/circle_layer.cpp b/platform/android/src/style/layers/circle_layer.cpp index 4a6ba95d31..948c397829 100644 --- a/platform/android/src/style/layers/circle_layer.cpp +++ b/platform/android/src/style/layers/circle_layer.cpp @@ -9,14 +9,27 @@ namespace mbgl { 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))) { } + /** + * 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) { } + /** + * 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() = default; // Property getters @@ -89,12 +102,12 @@ namespace android { } void CircleLayer::registerNative(jni::JNIEnv& env) { - //Lookup the class + // Lookup the class CircleLayer::javaClass = *jni::Class<CircleLayer>::Find(env).NewGlobalRef(env).release(); #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name) - //Register the peer + // Register the peer jni::RegisterNativePeer<CircleLayer>( env, CircleLayer::javaClass, "nativePtr", std::make_unique<CircleLayer, JNIEnv&, jni::String, jni::String>, diff --git a/platform/android/src/style/layers/circle_layer.hpp b/platform/android/src/style/layers/circle_layer.hpp index d45984f23b..ee988d7c57 100644 --- a/platform/android/src/style/layers/circle_layer.hpp +++ b/platform/android/src/style/layers/circle_layer.hpp @@ -22,6 +22,8 @@ public: CircleLayer(mbgl::Map&, mbgl::style::CircleLayer&); + CircleLayer(mbgl::Map&, std::unique_ptr<mbgl::style::CircleLayer>); + ~CircleLayer(); // Property getters diff --git a/platform/android/src/style/layers/custom_layer.cpp b/platform/android/src/style/layers/custom_layer.cpp index d5d330a019..9bdc308d85 100644 --- a/platform/android/src/style/layers/custom_layer.cpp +++ b/platform/android/src/style/layers/custom_layer.cpp @@ -40,12 +40,12 @@ namespace android { } void CustomLayer::registerNative(jni::JNIEnv& env) { - //Lookup the class + // Lookup the class CustomLayer::javaClass = *jni::Class<CustomLayer>::Find(env).NewGlobalRef(env).release(); #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name) - //Register the peer + // Register the peer jni::RegisterNativePeer<CustomLayer>( env, CustomLayer::javaClass, "nativePtr", std::make_unique<CustomLayer, JNIEnv&, jni::String, jni::jlong, jni::jlong, jni::jlong, jni::jlong>, diff --git a/platform/android/src/style/layers/fill_layer.cpp b/platform/android/src/style/layers/fill_layer.cpp index 84d47b6afe..fc1dfccfcc 100644 --- a/platform/android/src/style/layers/fill_layer.cpp +++ b/platform/android/src/style/layers/fill_layer.cpp @@ -9,14 +9,27 @@ namespace mbgl { 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))) { } + /** + * 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) { } + /** + * 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() = default; // Property getters @@ -71,12 +84,12 @@ namespace android { } void FillLayer::registerNative(jni::JNIEnv& env) { - //Lookup the class + // Lookup the class FillLayer::javaClass = *jni::Class<FillLayer>::Find(env).NewGlobalRef(env).release(); #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name) - //Register the peer + // Register the peer jni::RegisterNativePeer<FillLayer>( env, FillLayer::javaClass, "nativePtr", std::make_unique<FillLayer, JNIEnv&, jni::String, jni::String>, diff --git a/platform/android/src/style/layers/fill_layer.hpp b/platform/android/src/style/layers/fill_layer.hpp index 7609a5742f..f43c263ab8 100644 --- a/platform/android/src/style/layers/fill_layer.hpp +++ b/platform/android/src/style/layers/fill_layer.hpp @@ -22,6 +22,8 @@ public: FillLayer(mbgl::Map&, mbgl::style::FillLayer&); + FillLayer(mbgl::Map&, std::unique_ptr<mbgl::style::FillLayer>); + ~FillLayer(); // Property getters diff --git a/platform/android/src/style/layers/layer.cpp b/platform/android/src/style/layers/layer.cpp index c0c57c839d..dbf71fd2af 100644 --- a/platform/android/src/style/layers/layer.cpp +++ b/platform/android/src/style/layers/layer.cpp @@ -5,12 +5,12 @@ #include <mbgl/util/logging.hpp> -//Java -> C++ conversion +// Java -> C++ conversion #include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion/layer.hpp> #include <mbgl/style/conversion/source.hpp> -//C++ -> Java conversion +// C++ -> Java conversion #include "../conversion/property_value.hpp" #include <string> @@ -26,22 +26,35 @@ namespace android { , layer(*ownedLayer) { } + /** + * 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() { } void Layer::addToMap(mbgl::Map& _map, mbgl::optional<std::string> before) { - //Check to see if we own the layer first + // Check to see if we own the layer first if (!ownedLayer) { throw std::runtime_error("Cannot add layer twice"); } - //Add layer to map + // Add layer to map _map.addLayer(releaseCoreLayer(), before); - //Save pointer to the map + // Save pointer to the map this->map = &_map; } @@ -65,7 +78,7 @@ namespace android { void Layer::setLayoutProperty(jni::JNIEnv& env, jni::String jname, jni::Object<> jvalue) { Value value(env, jvalue); - //Convert and set property + // Convert and set property optional<mbgl::style::conversion::Error> error = mbgl::style::conversion::setLayoutProperty(layer, jni::Make<std::string>(env, jname), value); if (error) { mbgl::Log::Error(mbgl::Event::JNI, "Error setting property: " + jni::Make<std::string>(env, jname) + " " + error->message); @@ -76,7 +89,7 @@ namespace android { void Layer::setPaintProperty(jni::JNIEnv& env, jni::String jname, jni::Object<> jvalue) { Value value(env, jvalue); - //Convert and set property + // Convert and set property optional<mbgl::style::conversion::Error> error = mbgl::style::conversion::setPaintProperty(layer, jni::Make<std::string>(env, jname), value, mbgl::optional<std::string>()); if (error) { mbgl::Log::Error(mbgl::Event::JNI, "Error setting property: " + jni::Make<std::string>(env, jname) + " " + error->message); @@ -153,12 +166,12 @@ namespace android { jni::Class<Layer> Layer::javaClass; void Layer::registerNative(jni::JNIEnv& env) { - //Lookup the class + // Lookup the class Layer::javaClass = *jni::Class<Layer>::Find(env).NewGlobalRef(env).release(); #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name) - //Register the peer + // Register the peer jni::RegisterNativePeer<Layer>(env, Layer::javaClass, "nativePtr", METHOD(&Layer::getId, "nativeGetId"), METHOD(&Layer::setLayoutProperty, "nativeSetLayoutProperty"), @@ -174,5 +187,5 @@ namespace android { } -} //android -} //mbgl
\ No newline at end of file +} // namespace android +} // namespace mbgl diff --git a/platform/android/src/style/layers/layer.cpp.ejs b/platform/android/src/style/layers/layer.cpp.ejs index 500c76ea7a..5da397d77d 100644 --- a/platform/android/src/style/layers/layer.cpp.ejs +++ b/platform/android/src/style/layers/layer.cpp.ejs @@ -14,18 +14,34 @@ namespace mbgl { namespace android { <% if (type === 'background') { -%> + /** + * Creates an owning peer object (for layers not attached to the map) from the JVM side + */ <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(jni::JNIEnv& env, jni::String layerId) : Layer(env, 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))) { <% } -%> } + /** + * 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) { } + /** + * 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() = default; // Property getters @@ -46,12 +62,12 @@ namespace android { } void <%- camelize(type) %>Layer::registerNative(jni::JNIEnv& env) { - //Lookup the class + // Lookup the class <%- camelize(type) %>Layer::javaClass = *jni::Class<<%- camelize(type) %>Layer>::Find(env).NewGlobalRef(env).release(); #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name) - //Register the peer + // Register the peer jni::RegisterNativePeer<<%- camelize(type) %>Layer>( env, <%- camelize(type) %>Layer::javaClass, "nativePtr", <% if (type === 'background') { -%> diff --git a/platform/android/src/style/layers/layer.hpp b/platform/android/src/style/layers/layer.hpp index f3cd073552..deea7a6613 100644 --- a/platform/android/src/style/layers/layer.hpp +++ b/platform/android/src/style/layers/layer.hpp @@ -21,11 +21,16 @@ public: static void registerNative(jni::JNIEnv&); /* - * Called when a Java object is created on the c++ side + * 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>); @@ -49,7 +54,7 @@ public: void setPaintProperty(jni::JNIEnv&, jni::String, jni::Object<> value); - //Zoom + // Zoom jni::jfloat getMinZoom(jni::JNIEnv&); @@ -65,28 +70,24 @@ public: void setSourceLayer(jni::JNIEnv& env, jni::String sourceLayer); - //Property getters + // Property getters jni::Object<jni::ObjectTag> getVisibility(jni::JNIEnv&); protected: - //Release the owned view and return it + // Release the owned view and return it std::unique_ptr<mbgl::style::Layer> releaseCoreLayer(); - //Owned layer is set when creating a new layer, before adding it to the map + // Owned layer is set when creating a new layer, before adding it to the map std::unique_ptr<mbgl::style::Layer> ownedLayer; - //Raw reference to the layer + // Raw reference to the layer mbgl::style::Layer& layer; - //Map is set when the layer is retrieved or after adding to the map + // Map is set when the layer is retrieved or after adding to the map mbgl::Map* map; }; -} //android -} //mbgl - - - - +} // namespace android +} // namespace mbgl diff --git a/platform/android/src/style/layers/layer.hpp.ejs b/platform/android/src/style/layers/layer.hpp.ejs index 3d715746ff..102efd2d4d 100644 --- a/platform/android/src/style/layers/layer.hpp.ejs +++ b/platform/android/src/style/layers/layer.hpp.ejs @@ -30,6 +30,8 @@ public: <%- camelize(type) %>Layer(mbgl::Map&, mbgl::style::<%- camelize(type) %>Layer&); + <%- camelize(type) %>Layer(mbgl::Map&, std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer>); + ~<%- camelize(type) %>Layer(); // Property getters diff --git a/platform/android/src/style/layers/layers.cpp b/platform/android/src/style/layers/layers.cpp index 57dbf6f4b1..5c6ee1ae8f 100644 --- a/platform/android/src/style/layers/layers.cpp +++ b/platform/android/src/style/layers/layers.cpp @@ -1,5 +1,6 @@ #include "layers.hpp" +#include <mbgl/style/layer.hpp> #include <mbgl/style/layers/background_layer.hpp> #include <mbgl/style/layers/circle_layer.hpp> #include <mbgl/style/layers/fill_layer.hpp> @@ -10,55 +11,86 @@ #include "background_layer.hpp" #include "circle_layer.hpp" +#include "custom_layer.hpp" #include "fill_layer.hpp" #include "line_layer.hpp" #include "raster_layer.hpp" #include "symbol_layer.hpp" -#include "custom_layer.hpp" +#include "unknown_layer.hpp" namespace mbgl { namespace android { -Layer* initializeLayerPeer(mbgl::Map& map, mbgl::style::Layer& coreLayer) { - Layer* layer; +static Layer* initializeLayerPeer(mbgl::Map& map, mbgl::style::Layer& coreLayer) { if (coreLayer.is<mbgl::style::BackgroundLayer>()) { - layer = new BackgroundLayer(map, *coreLayer.as<mbgl::style::BackgroundLayer>()); + return new BackgroundLayer(map, *coreLayer.as<mbgl::style::BackgroundLayer>()); } else if (coreLayer.is<mbgl::style::CircleLayer>()) { - layer = new CircleLayer(map, *coreLayer.as<mbgl::style::CircleLayer>()); + return new CircleLayer(map, *coreLayer.as<mbgl::style::CircleLayer>()); } else if (coreLayer.is<mbgl::style::FillLayer>()) { - layer = new FillLayer(map, *coreLayer.as<mbgl::style::FillLayer>()); + return new FillLayer(map, *coreLayer.as<mbgl::style::FillLayer>()); } else if (coreLayer.is<mbgl::style::LineLayer>()) { - layer = new LineLayer(map, *coreLayer.as<mbgl::style::LineLayer>()); + return new LineLayer(map, *coreLayer.as<mbgl::style::LineLayer>()); } else if (coreLayer.is<mbgl::style::RasterLayer>()) { - layer = new RasterLayer(map, *coreLayer.as<mbgl::style::RasterLayer>()); + return new RasterLayer(map, *coreLayer.as<mbgl::style::RasterLayer>()); } else if (coreLayer.is<mbgl::style::SymbolLayer>()) { - layer = new SymbolLayer(map, *coreLayer.as<mbgl::style::SymbolLayer>()); + return new SymbolLayer(map, *coreLayer.as<mbgl::style::SymbolLayer>()); } else if (coreLayer.is<mbgl::style::CustomLayer>()) { - layer = new CustomLayer(map, *coreLayer.as<mbgl::style::CustomLayer>()); + return new CustomLayer(map, *coreLayer.as<mbgl::style::CustomLayer>()); } else { - throw new std::runtime_error("Layer type not implemented"); + return new UnknownLayer(map, coreLayer); } +} - return layer; +template <class LayerType, class PeerType> +static PeerType* createPeer(Map& map, std::unique_ptr<mbgl::style::Layer> layer) { + return new PeerType(map, std::move(std::unique_ptr<LayerType>(layer.release()->as<LayerType>()))); +} + +static Layer* initializeLayerPeer(Map& map, std::unique_ptr<mbgl::style::Layer> coreLayer) { + if (coreLayer->is<style::BackgroundLayer>()) { + return createPeer<style::BackgroundLayer, BackgroundLayer>(map, std::move(coreLayer)); + } else if (coreLayer->is<style::CircleLayer>()) { + return createPeer<style::CircleLayer, CircleLayer>(map, std::move(coreLayer)); + } else if (coreLayer->is<style::FillLayer>()) { + return createPeer<style::FillLayer, FillLayer>(map, std::move(coreLayer)); + } else if (coreLayer->is<style::LineLayer>()) { + return createPeer<style::LineLayer, LineLayer>(map, std::move(coreLayer)); + } else if (coreLayer->is<style::RasterLayer>()) { + return createPeer<style::RasterLayer, RasterLayer>(map, std::move(coreLayer)); + } else if (coreLayer->is<style::SymbolLayer>()) { + return createPeer<style::SymbolLayer, SymbolLayer>(map, std::move(coreLayer)); + } else if (coreLayer->is<mbgl::style::CustomLayer>()) { + return createPeer<style::SymbolLayer, SymbolLayer>(map, std::move(coreLayer)); + } else { + return new UnknownLayer(map, std::move(coreLayer)); + } } -jni::jobject* createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style::Layer& coreLayer) { +jni::jobject* createJavaLayerPeer(jni::JNIEnv& env, Map& map, style::Layer& coreLayer) { std::unique_ptr<Layer> peerLayer = std::unique_ptr<Layer>(initializeLayerPeer(map, coreLayer)); jni::jobject* result = peerLayer->createJavaPeer(env); peerLayer.release(); return result; } +jni::jobject* createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> coreLayer) { + std::unique_ptr<Layer> peerLayer = std::unique_ptr<Layer>(initializeLayerPeer(map, std::move(coreLayer))); + jni::jobject* result = peerLayer->createJavaPeer(env); + peerLayer.release(); + return result; +} + void registerNativeLayers(jni::JNIEnv& env) { Layer::registerNative(env); BackgroundLayer::registerNative(env); CircleLayer::registerNative(env); + CustomLayer::registerNative(env); FillLayer::registerNative(env); LineLayer::registerNative(env); RasterLayer::registerNative(env); SymbolLayer::registerNative(env); - CustomLayer::registerNative(env); + UnknownLayer::registerNative(env); } -} //android -} //mbgl
\ No newline at end of file +} // namespace android +} // namespace mbgl diff --git a/platform/android/src/style/layers/layers.hpp b/platform/android/src/style/layers/layers.hpp index 0c979ec2cf..75863a324a 100644 --- a/platform/android/src/style/layers/layers.hpp +++ b/platform/android/src/style/layers/layers.hpp @@ -10,11 +10,17 @@ namespace mbgl { namespace android { -mbgl::android::Layer* initializeLayerPeer(mbgl::Map&, mbgl::style::Layer&); - +/** + * Create a non-owning peer + */ jni::jobject* createJavaLayerPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Layer&); +/** + * Create an owning peer + */ +jni::jobject* createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer>); + void registerNativeLayers(jni::JNIEnv&); } -}
\ No newline at end of file +} diff --git a/platform/android/src/style/layers/line_layer.cpp b/platform/android/src/style/layers/line_layer.cpp index 2dce8b618a..1a3a666a7b 100644 --- a/platform/android/src/style/layers/line_layer.cpp +++ b/platform/android/src/style/layers/line_layer.cpp @@ -9,14 +9,27 @@ namespace mbgl { 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))) { } + /** + * 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) { } + /** + * 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() = default; // Property getters @@ -113,12 +126,12 @@ namespace android { } void LineLayer::registerNative(jni::JNIEnv& env) { - //Lookup the class + // Lookup the class LineLayer::javaClass = *jni::Class<LineLayer>::Find(env).NewGlobalRef(env).release(); #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name) - //Register the peer + // Register the peer jni::RegisterNativePeer<LineLayer>( env, LineLayer::javaClass, "nativePtr", std::make_unique<LineLayer, JNIEnv&, jni::String, jni::String>, diff --git a/platform/android/src/style/layers/line_layer.hpp b/platform/android/src/style/layers/line_layer.hpp index e2fc93329e..a79c8b9021 100644 --- a/platform/android/src/style/layers/line_layer.hpp +++ b/platform/android/src/style/layers/line_layer.hpp @@ -22,6 +22,8 @@ public: LineLayer(mbgl::Map&, mbgl::style::LineLayer&); + LineLayer(mbgl::Map&, std::unique_ptr<mbgl::style::LineLayer>); + ~LineLayer(); // Property getters diff --git a/platform/android/src/style/layers/raster_layer.cpp b/platform/android/src/style/layers/raster_layer.cpp index 25b26155ae..8a324b88f2 100644 --- a/platform/android/src/style/layers/raster_layer.cpp +++ b/platform/android/src/style/layers/raster_layer.cpp @@ -9,14 +9,27 @@ namespace mbgl { 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))) { } + /** + * 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) { } + /** + * 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() = default; // Property getters @@ -71,12 +84,12 @@ namespace android { } void RasterLayer::registerNative(jni::JNIEnv& env) { - //Lookup the class + // Lookup the class RasterLayer::javaClass = *jni::Class<RasterLayer>::Find(env).NewGlobalRef(env).release(); #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name) - //Register the peer + // Register the peer jni::RegisterNativePeer<RasterLayer>( env, RasterLayer::javaClass, "nativePtr", std::make_unique<RasterLayer, JNIEnv&, jni::String, jni::String>, diff --git a/platform/android/src/style/layers/raster_layer.hpp b/platform/android/src/style/layers/raster_layer.hpp index 3cc2d96dde..2f5d4f6fcd 100644 --- a/platform/android/src/style/layers/raster_layer.hpp +++ b/platform/android/src/style/layers/raster_layer.hpp @@ -22,6 +22,8 @@ public: RasterLayer(mbgl::Map&, mbgl::style::RasterLayer&); + RasterLayer(mbgl::Map&, std::unique_ptr<mbgl::style::RasterLayer>); + ~RasterLayer(); // Property getters diff --git a/platform/android/src/style/layers/symbol_layer.cpp b/platform/android/src/style/layers/symbol_layer.cpp index 9318d42d5b..e42eeb4c77 100644 --- a/platform/android/src/style/layers/symbol_layer.cpp +++ b/platform/android/src/style/layers/symbol_layer.cpp @@ -9,14 +9,27 @@ namespace mbgl { 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))) { } + /** + * 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) { } + /** + * 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() = default; // Property getters @@ -317,12 +330,12 @@ namespace android { } void SymbolLayer::registerNative(jni::JNIEnv& env) { - //Lookup the class + // Lookup the class SymbolLayer::javaClass = *jni::Class<SymbolLayer>::Find(env).NewGlobalRef(env).release(); #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name) - //Register the peer + // Register the peer jni::RegisterNativePeer<SymbolLayer>( env, SymbolLayer::javaClass, "nativePtr", std::make_unique<SymbolLayer, JNIEnv&, jni::String, jni::String>, diff --git a/platform/android/src/style/layers/symbol_layer.hpp b/platform/android/src/style/layers/symbol_layer.hpp index 1048b01b14..98ce5572e9 100644 --- a/platform/android/src/style/layers/symbol_layer.hpp +++ b/platform/android/src/style/layers/symbol_layer.hpp @@ -22,6 +22,8 @@ public: SymbolLayer(mbgl::Map&, mbgl::style::SymbolLayer&); + SymbolLayer(mbgl::Map&, std::unique_ptr<mbgl::style::SymbolLayer>); + ~SymbolLayer(); // Property getters diff --git a/platform/android/src/style/layers/unknown_layer.cpp b/platform/android/src/style/layers/unknown_layer.cpp new file mode 100644 index 0000000000..9ec963a41b --- /dev/null +++ b/platform/android/src/style/layers/unknown_layer.cpp @@ -0,0 +1,49 @@ +#include "unknown_layer.hpp" + +#include <string> + +namespace { + + // Dummy initializer (We don't support initializing this from the JVM) + std::unique_ptr<mbgl::android::UnknownLayer> init(jni::JNIEnv&) { + throw new std::runtime_error("UnknownLayer should not be initialized from the JVM"); + } + +} // namespace + +namespace mbgl { +namespace android { + + UnknownLayer::UnknownLayer(mbgl::Map& map, mbgl::style::Layer& coreLayer) + : Layer(map, coreLayer) { + } + + UnknownLayer::UnknownLayer(mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> coreLayer) + : Layer(map, std::move(coreLayer)) { + } + + jni::Class<UnknownLayer> UnknownLayer::javaClass; + + jni::jobject* UnknownLayer::createJavaPeer(jni::JNIEnv& env) { + static auto constructor = UnknownLayer::javaClass.template GetConstructor<jni::jlong>(env); + return UnknownLayer::javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this)); + } + + void UnknownLayer::registerNative(jni::JNIEnv& env) { + // Lookup the class + UnknownLayer::javaClass = *jni::Class<UnknownLayer>::Find(env).NewGlobalRef(env).release(); + + #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name) + + std::function<std::unique_ptr<UnknownLayer>(JNIEnv&)> initializer = nullptr; + + // Register the peer + jni::RegisterNativePeer<UnknownLayer>( + env, UnknownLayer::javaClass, "nativePtr", + init, + "initialize", + "finalize"); + } + +} // namespace android +} // namespace mbgl diff --git a/platform/android/src/style/layers/unknown_layer.hpp b/platform/android/src/style/layers/unknown_layer.hpp new file mode 100644 index 0000000000..67992ea007 --- /dev/null +++ b/platform/android/src/style/layers/unknown_layer.hpp @@ -0,0 +1,30 @@ +#pragma once + +#include "layer.hpp" +#include <mbgl/style/layer.hpp> +#include <jni/jni.hpp> + +namespace mbgl { +namespace android { + +class UnknownLayer : public Layer { +public: + + static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/UnknownLayer"; }; + + static jni::Class<UnknownLayer> javaClass; + + static void registerNative(jni::JNIEnv&); + + UnknownLayer(mbgl::Map&, mbgl::style::Layer&); + + UnknownLayer(mbgl::Map&, std::unique_ptr<mbgl::style::Layer>); + + ~UnknownLayer() = default; + + jni::jobject* createJavaPeer(jni::JNIEnv&); + +}; // class UnknownLayer + +} // namespace android +} // namespace mbgl |