diff options
Diffstat (limited to 'platform/android/src/style/layers')
19 files changed, 1076 insertions, 92 deletions
diff --git a/platform/android/src/style/layers/background_layer.cpp b/platform/android/src/style/layers/background_layer.cpp index 4847d59420..25526a07fa 100644 --- a/platform/android/src/style/layers/background_layer.cpp +++ b/platform/android/src/style/layers/background_layer.cpp @@ -4,25 +4,41 @@ #include <string> -//XXX -#include <mbgl/platform/log.hpp> +#include "../conversion/property_value.hpp" namespace mbgl { namespace android { BackgroundLayer::BackgroundLayer(jni::JNIEnv& env, jni::String layerId) : Layer(env, std::make_unique<mbgl::style::BackgroundLayer>(jni::Make<std::string>(env, layerId))) { - mbgl::Log::Debug(mbgl::Event::JNI, "BackgroundLayer constructed, owning reference"); } BackgroundLayer::BackgroundLayer(mbgl::Map& map, mbgl::style::BackgroundLayer& coreLayer) : Layer(map, coreLayer) { - - mbgl::Log::Debug(mbgl::Event::JNI, "BackgroundLayer Non-owning reference constructor"); } BackgroundLayer::~BackgroundLayer() = default; + // Property getters + + jni::Object<jni::ObjectTag> BackgroundLayer::getBackgroundColor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundColor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> BackgroundLayer::getBackgroundPattern(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundPattern()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> BackgroundLayer::getBackgroundOpacity(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundOpacity()); + return jni::Object<jni::ObjectTag>(*converted); + } + jni::Class<BackgroundLayer> BackgroundLayer::javaClass; jni::jobject* BackgroundLayer::createJavaPeer(jni::JNIEnv& env) { @@ -31,8 +47,6 @@ namespace android { } void BackgroundLayer::registerNative(jni::JNIEnv& env) { - mbgl::Log::Debug(mbgl::Event::JNI, "Registering native background layer"); - //Lookup the class BackgroundLayer::javaClass = *jni::Class<BackgroundLayer>::Find(env).NewGlobalRef(env).release(); @@ -43,9 +57,10 @@ namespace android { env, BackgroundLayer::javaClass, "nativePtr", std::make_unique<BackgroundLayer, JNIEnv&, jni::String>, "initialize", - "finalize" - ); - + "finalize", + METHOD(&BackgroundLayer::getBackgroundColor, "nativeGetBackgroundColor"), + METHOD(&BackgroundLayer::getBackgroundPattern, "nativeGetBackgroundPattern"), + METHOD(&BackgroundLayer::getBackgroundOpacity, "nativeGetBackgroundOpacity")); } } // namespace android diff --git a/platform/android/src/style/layers/background_layer.hpp b/platform/android/src/style/layers/background_layer.hpp index b253b4861c..f201213e46 100644 --- a/platform/android/src/style/layers/background_layer.hpp +++ b/platform/android/src/style/layers/background_layer.hpp @@ -24,8 +24,16 @@ public: ~BackgroundLayer(); + // Property getters + jni::Object<jni::ObjectTag> getBackgroundColor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getBackgroundPattern(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getBackgroundOpacity(jni::JNIEnv&); + jni::jobject* createJavaPeer(jni::JNIEnv&); -}; + +}; // class BackgroundLayer } // namespace android } // namespace mbgl diff --git a/platform/android/src/style/layers/circle_layer.cpp b/platform/android/src/style/layers/circle_layer.cpp index ad0d0b34ce..c2d6ff06d1 100644 --- a/platform/android/src/style/layers/circle_layer.cpp +++ b/platform/android/src/style/layers/circle_layer.cpp @@ -4,25 +4,65 @@ #include <string> -//XXX -#include <mbgl/platform/log.hpp> +#include "../conversion/property_value.hpp" namespace mbgl { namespace android { 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))) { - mbgl::Log::Debug(mbgl::Event::JNI, "CircleLayer constructed, owning reference"); } CircleLayer::CircleLayer(mbgl::Map& map, mbgl::style::CircleLayer& coreLayer) : Layer(map, coreLayer) { - - mbgl::Log::Debug(mbgl::Event::JNI, "CircleLayer Non-owning reference constructor"); } CircleLayer::~CircleLayer() = default; + // Property getters + + jni::Object<jni::ObjectTag> CircleLayer::getCircleRadius(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCircleRadius()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> CircleLayer::getCircleColor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCircleColor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> CircleLayer::getCircleBlur(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCircleBlur()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> CircleLayer::getCircleOpacity(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCircleOpacity()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> CircleLayer::getCircleTranslate(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCircleTranslate()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> CircleLayer::getCircleTranslateAnchor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCircleTranslateAnchor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> CircleLayer::getCirclePitchScale(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::CircleLayer>()->CircleLayer::getCirclePitchScale()); + return jni::Object<jni::ObjectTag>(*converted); + } + jni::Class<CircleLayer> CircleLayer::javaClass; jni::jobject* CircleLayer::createJavaPeer(jni::JNIEnv& env) { @@ -31,8 +71,6 @@ namespace android { } void CircleLayer::registerNative(jni::JNIEnv& env) { - mbgl::Log::Debug(mbgl::Event::JNI, "Registering native background layer"); - //Lookup the class CircleLayer::javaClass = *jni::Class<CircleLayer>::Find(env).NewGlobalRef(env).release(); @@ -43,9 +81,14 @@ namespace android { env, CircleLayer::javaClass, "nativePtr", std::make_unique<CircleLayer, JNIEnv&, jni::String, jni::String>, "initialize", - "finalize" - ); - + "finalize", + METHOD(&CircleLayer::getCircleRadius, "nativeGetCircleRadius"), + METHOD(&CircleLayer::getCircleColor, "nativeGetCircleColor"), + METHOD(&CircleLayer::getCircleBlur, "nativeGetCircleBlur"), + METHOD(&CircleLayer::getCircleOpacity, "nativeGetCircleOpacity"), + METHOD(&CircleLayer::getCircleTranslate, "nativeGetCircleTranslate"), + METHOD(&CircleLayer::getCircleTranslateAnchor, "nativeGetCircleTranslateAnchor"), + METHOD(&CircleLayer::getCirclePitchScale, "nativeGetCirclePitchScale")); } } // namespace android diff --git a/platform/android/src/style/layers/circle_layer.hpp b/platform/android/src/style/layers/circle_layer.hpp index e0dc94eb00..91c99c686e 100644 --- a/platform/android/src/style/layers/circle_layer.hpp +++ b/platform/android/src/style/layers/circle_layer.hpp @@ -24,8 +24,24 @@ public: ~CircleLayer(); + // Property getters + jni::Object<jni::ObjectTag> getCircleRadius(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getCircleColor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getCircleBlur(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getCircleOpacity(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getCircleTranslate(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getCircleTranslateAnchor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getCirclePitchScale(jni::JNIEnv&); + jni::jobject* createJavaPeer(jni::JNIEnv&); -}; + +}; // class CircleLayer } // namespace android } // namespace mbgl diff --git a/platform/android/src/style/layers/custom_layer.cpp b/platform/android/src/style/layers/custom_layer.cpp new file mode 100644 index 0000000000..4be6f3800d --- /dev/null +++ b/platform/android/src/style/layers/custom_layer.cpp @@ -0,0 +1,57 @@ +#include "custom_layer.hpp" + +#include <string> + +#include <mbgl/platform/log.hpp> + +namespace mbgl { +namespace android { + + CustomLayer::CustomLayer(jni::JNIEnv& env, jni::String layerId, jni::jlong initializeFunction, jni::jlong renderFunction, jni::jlong deinitializeFunction, jni::jlong context) + : Layer(env, std::make_unique<mbgl::style::CustomLayer>( + jni::Make<std::string>(env, layerId), + reinterpret_cast<mbgl::style::CustomLayerInitializeFunction>(initializeFunction), + reinterpret_cast<mbgl::style::CustomLayerRenderFunction>(renderFunction), + reinterpret_cast<mbgl::style::CustomLayerDeinitializeFunction>(deinitializeFunction), + reinterpret_cast<void*>(context)) + ) { + } + + CustomLayer::CustomLayer(mbgl::Map& map, mbgl::style::CustomLayer& coreLayer) + : Layer(map, coreLayer) { + } + + CustomLayer::~CustomLayer() = default; + + void CustomLayer::update(jni::JNIEnv&) { + if (map) { + map->update(mbgl::Update::Repaint); + } else { + Log::Error(mbgl::Event::JNI, "No map reference, cannot update"); + } + } + + jni::Class<CustomLayer> CustomLayer::javaClass; + + jni::jobject* CustomLayer::createJavaPeer(jni::JNIEnv& env) { + static auto constructor = CustomLayer::javaClass.template GetConstructor<jni::jlong>(env); + return CustomLayer::javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this)); + } + + void CustomLayer::registerNative(jni::JNIEnv& env) { + //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 + jni::RegisterNativePeer<CustomLayer>( + env, CustomLayer::javaClass, "nativePtr", + std::make_unique<CustomLayer, JNIEnv&, jni::String, jni::jlong, jni::jlong, jni::jlong, jni::jlong>, + "initialize", + "finalize", + METHOD(&CustomLayer::update, "nativeUpdate")); + } + +} // namespace android +} // namespace mbgl diff --git a/platform/android/src/style/layers/custom_layer.hpp b/platform/android/src/style/layers/custom_layer.hpp new file mode 100644 index 0000000000..1173d21bfd --- /dev/null +++ b/platform/android/src/style/layers/custom_layer.hpp @@ -0,0 +1,32 @@ +#pragma once + +#include "layer.hpp" +#include <mbgl/style/layers/custom_layer.hpp> +#include <jni/jni.hpp> + +namespace mbgl { +namespace android { + +class CustomLayer : public Layer { +public: + + static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/CustomLayer"; }; + + static jni::Class<CustomLayer> javaClass; + + static void registerNative(jni::JNIEnv&); + + CustomLayer(jni::JNIEnv&, jni::String, jni::jlong, jni::jlong, jni::jlong, jni::jlong); + + CustomLayer(mbgl::Map&, mbgl::style::CustomLayer&); + + ~CustomLayer(); + + void update(jni::JNIEnv&); + + jni::jobject* createJavaPeer(jni::JNIEnv&); + +}; // class CustomLayer + +} // namespace android +} // namespace mbgl diff --git a/platform/android/src/style/layers/fill_layer.cpp b/platform/android/src/style/layers/fill_layer.cpp index 1056c8353b..8cb96c9cd3 100644 --- a/platform/android/src/style/layers/fill_layer.cpp +++ b/platform/android/src/style/layers/fill_layer.cpp @@ -4,25 +4,65 @@ #include <string> -//XXX -#include <mbgl/platform/log.hpp> +#include "../conversion/property_value.hpp" namespace mbgl { namespace android { 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))) { - mbgl::Log::Debug(mbgl::Event::JNI, "FillLayer constructed, owning reference"); } FillLayer::FillLayer(mbgl::Map& map, mbgl::style::FillLayer& coreLayer) : Layer(map, coreLayer) { - - mbgl::Log::Debug(mbgl::Event::JNI, "FillLayer Non-owning reference constructor"); } FillLayer::~FillLayer() = default; + // Property getters + + jni::Object<jni::ObjectTag> FillLayer::getFillAntialias(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillAntialias()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> FillLayer::getFillOpacity(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillOpacity()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> FillLayer::getFillColor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillColor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> FillLayer::getFillOutlineColor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillOutlineColor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> FillLayer::getFillTranslate(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillTranslate()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> FillLayer::getFillTranslateAnchor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillTranslateAnchor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> FillLayer::getFillPattern(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::FillLayer>()->FillLayer::getFillPattern()); + return jni::Object<jni::ObjectTag>(*converted); + } + jni::Class<FillLayer> FillLayer::javaClass; jni::jobject* FillLayer::createJavaPeer(jni::JNIEnv& env) { @@ -31,8 +71,6 @@ namespace android { } void FillLayer::registerNative(jni::JNIEnv& env) { - mbgl::Log::Debug(mbgl::Event::JNI, "Registering native background layer"); - //Lookup the class FillLayer::javaClass = *jni::Class<FillLayer>::Find(env).NewGlobalRef(env).release(); @@ -43,9 +81,14 @@ namespace android { env, FillLayer::javaClass, "nativePtr", std::make_unique<FillLayer, JNIEnv&, jni::String, jni::String>, "initialize", - "finalize" - ); - + "finalize", + METHOD(&FillLayer::getFillAntialias, "nativeGetFillAntialias"), + METHOD(&FillLayer::getFillOpacity, "nativeGetFillOpacity"), + METHOD(&FillLayer::getFillColor, "nativeGetFillColor"), + METHOD(&FillLayer::getFillOutlineColor, "nativeGetFillOutlineColor"), + METHOD(&FillLayer::getFillTranslate, "nativeGetFillTranslate"), + METHOD(&FillLayer::getFillTranslateAnchor, "nativeGetFillTranslateAnchor"), + METHOD(&FillLayer::getFillPattern, "nativeGetFillPattern")); } } // namespace android diff --git a/platform/android/src/style/layers/fill_layer.hpp b/platform/android/src/style/layers/fill_layer.hpp index 5ed80d401f..5dbd7a3412 100644 --- a/platform/android/src/style/layers/fill_layer.hpp +++ b/platform/android/src/style/layers/fill_layer.hpp @@ -24,8 +24,24 @@ public: ~FillLayer(); + // Property getters + jni::Object<jni::ObjectTag> getFillAntialias(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getFillOpacity(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getFillColor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getFillOutlineColor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getFillTranslate(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getFillTranslateAnchor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getFillPattern(jni::JNIEnv&); + jni::jobject* createJavaPeer(jni::JNIEnv&); -}; + +}; // class FillLayer } // namespace android } // namespace mbgl diff --git a/platform/android/src/style/layers/layer.cpp b/platform/android/src/style/layers/layer.cpp index aec7079698..4d5f90f67e 100644 --- a/platform/android/src/style/layers/layer.cpp +++ b/platform/android/src/style/layers/layer.cpp @@ -4,10 +4,15 @@ #include <jni/jni.hpp> #include <mbgl/platform/log.hpp> + +//Java -> C++ conversion #include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion/layer.hpp> #include <mbgl/style/conversion/source.hpp> +//C++ -> Java conversion +#include "../conversion/property_value.hpp" + #include <string> namespace mbgl { @@ -16,19 +21,15 @@ namespace android { /** * Invoked when the construction is initiated from the jvm through a subclass */ - Layer::Layer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> coreLayer) + Layer::Layer(jni::JNIEnv&, std::unique_ptr<mbgl::style::Layer> coreLayer) : ownedLayer(std::move(coreLayer)) , layer(*ownedLayer) { - - mbgl::Log::Debug(mbgl::Event::JNI, "Layer constructed, owning reference"); } Layer::Layer(mbgl::Map& coreMap, mbgl::style::Layer& coreLayer) : layer(coreLayer) , map(&coreMap) { - mbgl::Log::Debug(mbgl::Event::JNI, "Non-owning reference constructor"); } Layer::~Layer() { - mbgl::Log::Debug(mbgl::Event::JNI, "Layer destroyed"); } jni::String Layer::getId(jni::JNIEnv& env) { @@ -41,8 +42,6 @@ namespace android { } void Layer::setLayoutProperty(jni::JNIEnv& env, jni::String jname, jni::Object<> jvalue) { - mbgl::Log::Debug(mbgl::Event::JNI, "Set layout property"); - Value value(env, jvalue); //Convert and set property @@ -51,16 +50,9 @@ namespace android { mbgl::Log::Error(mbgl::Event::JNI, "Error setting property: " + jni::Make<std::string>(env, jname) + " " + error->message); return; } - - //Update the style if attached - if (ownedLayer == nullptr) { - map->update(mbgl::Update::RecalculateStyle); - } } void Layer::setPaintProperty(jni::JNIEnv& env, jni::String jname, jni::Object<> jvalue) { - mbgl::Log::Debug(mbgl::Event::JNI, "Set paint property"); - Value value(env, jvalue); //Convert and set property @@ -72,8 +64,6 @@ namespace android { } void Layer::updateStyle(jni::JNIEnv&, jni::jboolean updateClasses) { - mbgl::Log::Debug(mbgl::Event::JNI, "Update style property. Update classes: " + std::to_string(updateClasses)); - //Update the style only if attached if (ownedLayer == nullptr) { Update flags = mbgl::Update::RecalculateStyle; @@ -89,7 +79,6 @@ namespace android { void Layer::setFilter(jni::JNIEnv& env, jni::Array<jni::Object<>> jfilter) { using namespace mbgl::style; using namespace mbgl::style::conversion; - mbgl::Log::Debug(mbgl::Event::JNI, "Set filter"); Value wrapped(env, jfilter); Filter filter; @@ -118,7 +107,6 @@ namespace android { using namespace mbgl::style; std::string layerId = jni::Make<std::string>(env, sourceLayer); - mbgl::Log::Debug(mbgl::Event::JNI, "Set source layer: " + layerId); if (layer.is<FillLayer>()) { layer.as<FillLayer>()->setSourceLayer(layerId); @@ -133,11 +121,30 @@ namespace android { } } + jni::jfloat Layer::getMinZoom(jni::JNIEnv&){ + return layer.getMinZoom(); + } + + jni::jfloat Layer::getMaxZoom(jni::JNIEnv&) { + return layer.getMaxZoom(); + } + + void Layer::setMinZoom(jni::JNIEnv&, jni::jfloat zoom) { + layer.setMinZoom(zoom); + } + + void Layer::setMaxZoom(jni::JNIEnv&, jni::jfloat zoom) { + layer.setMaxZoom(zoom); + } + + jni::Object<jni::ObjectTag> Layer::getVisibility(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + return jni::Object<jni::ObjectTag>(*convert<jni::jobject*>(env, layer.getVisibility())); + } + jni::Class<Layer> Layer::javaClass; void Layer::registerNative(jni::JNIEnv& env) { - mbgl::Log::Debug(mbgl::Event::JNI, "Registering native base layer"); - //Lookup the class Layer::javaClass = *jni::Class<Layer>::Find(env).NewGlobalRef(env).release(); @@ -150,9 +157,15 @@ namespace android { METHOD(&Layer::setPaintProperty, "nativeSetPaintProperty"), METHOD(&Layer::updateStyle, "nativeUpdateStyle"), METHOD(&Layer::setFilter, "nativeSetFilter"), - METHOD(&Layer::setSourceLayer, "nativeSetSourceLayer") + METHOD(&Layer::setSourceLayer, "nativeSetSourceLayer"), + METHOD(&Layer::getMinZoom, "nativeGetMinZoom"), + METHOD(&Layer::getMaxZoom, "nativeGetMaxZoom"), + METHOD(&Layer::setMinZoom, "nativeSetMinZoom"), + METHOD(&Layer::setMaxZoom, "nativeSetMaxZoom"), + METHOD(&Layer::getVisibility, "nativeGetVisibility") ); } -} -}
\ No newline at end of file + +} //android +} //mbgl
\ No newline at end of file diff --git a/platform/android/src/style/layers/layer.cpp.ejs b/platform/android/src/style/layers/layer.cpp.ejs new file mode 100644 index 0000000000..68dd27b801 --- /dev/null +++ b/platform/android/src/style/layers/layer.cpp.ejs @@ -0,0 +1,69 @@ +<% + const type = locals.type; + const properties = locals.properties; +-%> +// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make style-code-android`. + +#include "<%- type %>_layer.hpp" + +#include <string> + +#include "../conversion/property_value.hpp" + +namespace mbgl { +namespace android { + +<% if (type === 'background') { -%> + <%- 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 { -%> + <%- 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))) { +<% } -%> + } + + <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(mbgl::Map& map, mbgl::style::<%- camelize(type) %>Layer& coreLayer) + : Layer(map, coreLayer) { + } + + <%- camelize(type) %>Layer::~<%- camelize(type) %>Layer() = default; + + // Property getters + +<% for (const property of properties) { -%> + jni::Object<jni::ObjectTag> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::<%- camelize(type) %>Layer>()-><%- camelize(type) %>Layer::get<%- camelize(property.name) %>()); + return jni::Object<jni::ObjectTag>(*converted); + } + +<% } -%> + jni::Class<<%- camelize(type) %>Layer> <%- camelize(type) %>Layer::javaClass; + + jni::jobject* <%- camelize(type) %>Layer::createJavaPeer(jni::JNIEnv& env) { + static auto constructor = <%- camelize(type) %>Layer::javaClass.template GetConstructor<jni::jlong>(env); + return <%- camelize(type) %>Layer::javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this)); + } + + void <%- camelize(type) %>Layer::registerNative(jni::JNIEnv& env) { + //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 + jni::RegisterNativePeer<<%- camelize(type) %>Layer>( + env, <%- camelize(type) %>Layer::javaClass, "nativePtr", +<% if (type === 'background') { -%> + std::make_unique<<%- camelize(type) %>Layer, JNIEnv&, jni::String>, +<% } else { -%> + std::make_unique<<%- camelize(type) %>Layer, JNIEnv&, jni::String, jni::String>, +<% } -%> + "initialize", + "finalize",<% for(var i = 0; i < properties.length; i++) {%> + METHOD(&<%- camelize(type) %>Layer::get<%- camelize(properties[i].name) %>, "nativeGet<%- camelize(properties[i].name) %>")<% if(i != (properties.length -1)) {-%>,<% } -%> +<% } -%>); + } + +} // namespace android +} // namespace mbgl diff --git a/platform/android/src/style/layers/layer.hpp b/platform/android/src/style/layers/layer.hpp index 8b3487551b..37eb34cdd7 100644 --- a/platform/android/src/style/layers/layer.hpp +++ b/platform/android/src/style/layers/layer.hpp @@ -45,12 +45,26 @@ public: void updateStyle(jni::JNIEnv&, jni::jboolean updateClasses); + //Zoom + + jni::jfloat getMinZoom(jni::JNIEnv&); + + jni::jfloat getMaxZoom(jni::JNIEnv&); + + void setMinZoom(jni::JNIEnv&, jni::jfloat zoom); + + void setMaxZoom(jni::JNIEnv&, jni::jfloat zoom); + /* common properties, but not shared by all */ void setFilter(jni::JNIEnv& env, jni::Array<jni::Object<>> jfilter); void setSourceLayer(jni::JNIEnv& env, jni::String sourceLayer); + //Property getters + + jni::Object<jni::ObjectTag> getVisibility(jni::JNIEnv&); + protected: std::unique_ptr<mbgl::style::Layer> ownedLayer; mbgl::style::Layer& layer; diff --git a/platform/android/src/style/layers/layer.hpp.ejs b/platform/android/src/style/layers/layer.hpp.ejs new file mode 100644 index 0000000000..826e133fca --- /dev/null +++ b/platform/android/src/style/layers/layer.hpp.ejs @@ -0,0 +1,45 @@ +<% + const type = locals.type; + const properties = locals.properties; +-%> +// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make style-code-android`. + +#pragma once + +#include "layer.hpp" +#include <mbgl/style/layers/<%- type %>_layer.hpp> +#include <jni/jni.hpp> + +namespace mbgl { +namespace android { + +class <%- camelize(type) %>Layer : public Layer { +public: + + static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/<%- camelize(type) %>Layer"; }; + + static jni::Class<<%- camelize(type) %>Layer> javaClass; + + static void registerNative(jni::JNIEnv&); + +<% if (type === 'background') { -%> + <%- camelize(type) %>Layer(jni::JNIEnv&, jni::String); +<% } else { -%> + <%- camelize(type) %>Layer(jni::JNIEnv&, jni::String, jni::String); +<% } -%> + + <%- camelize(type) %>Layer(mbgl::Map&, mbgl::style::<%- camelize(type) %>Layer&); + + ~<%- camelize(type) %>Layer(); + + // Property getters +<% for (const property of properties) { -%> + jni::Object<jni::ObjectTag> get<%- camelize(property.name) %>(jni::JNIEnv&); + +<% } -%> + jni::jobject* createJavaPeer(jni::JNIEnv&); + +}; // class <%- camelize(type) %>Layer + +} // namespace android +} // namespace mbgl diff --git a/platform/android/src/style/layers/layers.cpp b/platform/android/src/style/layers/layers.cpp index 4ccdc829f2..57dbf6f4b1 100644 --- a/platform/android/src/style/layers/layers.cpp +++ b/platform/android/src/style/layers/layers.cpp @@ -6,6 +6,7 @@ #include <mbgl/style/layers/line_layer.hpp> #include <mbgl/style/layers/raster_layer.hpp> #include <mbgl/style/layers/symbol_layer.hpp> +#include <mbgl/style/layers/custom_layer.hpp> #include "background_layer.hpp" #include "circle_layer.hpp" @@ -13,6 +14,7 @@ #include "line_layer.hpp" #include "raster_layer.hpp" #include "symbol_layer.hpp" +#include "custom_layer.hpp" namespace mbgl { namespace android { @@ -31,6 +33,8 @@ Layer* initializeLayerPeer(mbgl::Map& map, mbgl::style::Layer& coreLayer) { layer = new RasterLayer(map, *coreLayer.as<mbgl::style::RasterLayer>()); } else if (coreLayer.is<mbgl::style::SymbolLayer>()) { layer = new SymbolLayer(map, *coreLayer.as<mbgl::style::SymbolLayer>()); + } else if (coreLayer.is<mbgl::style::CustomLayer>()) { + layer = new CustomLayer(map, *coreLayer.as<mbgl::style::CustomLayer>()); } else { throw new std::runtime_error("Layer type not implemented"); } @@ -42,7 +46,6 @@ jni::jobject* createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, mbgl::style: std::unique_ptr<Layer> peerLayer = std::unique_ptr<Layer>(initializeLayerPeer(map, coreLayer)); jni::jobject* result = peerLayer->createJavaPeer(env); peerLayer.release(); - return result; } @@ -54,7 +57,8 @@ void registerNativeLayers(jni::JNIEnv& env) { LineLayer::registerNative(env); RasterLayer::registerNative(env); SymbolLayer::registerNative(env); + CustomLayer::registerNative(env); } -} -}
\ No newline at end of file +} //android +} //mbgl
\ 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 fdf2af7973..91d3e4a1cd 100644 --- a/platform/android/src/style/layers/line_layer.cpp +++ b/platform/android/src/style/layers/line_layer.cpp @@ -4,25 +4,107 @@ #include <string> -//XXX -#include <mbgl/platform/log.hpp> +#include "../conversion/property_value.hpp" namespace mbgl { namespace android { 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))) { - mbgl::Log::Debug(mbgl::Event::JNI, "LineLayer constructed, owning reference"); } LineLayer::LineLayer(mbgl::Map& map, mbgl::style::LineLayer& coreLayer) : Layer(map, coreLayer) { - - mbgl::Log::Debug(mbgl::Event::JNI, "LineLayer Non-owning reference constructor"); } LineLayer::~LineLayer() = default; + // Property getters + + jni::Object<jni::ObjectTag> LineLayer::getLineCap(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineCap()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> LineLayer::getLineJoin(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineJoin()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> LineLayer::getLineMiterLimit(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineMiterLimit()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> LineLayer::getLineRoundLimit(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineRoundLimit()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> LineLayer::getLineOpacity(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineOpacity()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> LineLayer::getLineColor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineColor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> LineLayer::getLineTranslate(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineTranslate()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> LineLayer::getLineTranslateAnchor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineTranslateAnchor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> LineLayer::getLineWidth(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineWidth()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> LineLayer::getLineGapWidth(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineGapWidth()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> LineLayer::getLineOffset(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineOffset()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> LineLayer::getLineBlur(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineBlur()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> LineLayer::getLineDasharray(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLineDasharray()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> LineLayer::getLinePattern(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::LineLayer>()->LineLayer::getLinePattern()); + return jni::Object<jni::ObjectTag>(*converted); + } + jni::Class<LineLayer> LineLayer::javaClass; jni::jobject* LineLayer::createJavaPeer(jni::JNIEnv& env) { @@ -31,8 +113,6 @@ namespace android { } void LineLayer::registerNative(jni::JNIEnv& env) { - mbgl::Log::Debug(mbgl::Event::JNI, "Registering native background layer"); - //Lookup the class LineLayer::javaClass = *jni::Class<LineLayer>::Find(env).NewGlobalRef(env).release(); @@ -43,9 +123,21 @@ namespace android { env, LineLayer::javaClass, "nativePtr", std::make_unique<LineLayer, JNIEnv&, jni::String, jni::String>, "initialize", - "finalize" - ); - + "finalize", + METHOD(&LineLayer::getLineCap, "nativeGetLineCap"), + METHOD(&LineLayer::getLineJoin, "nativeGetLineJoin"), + METHOD(&LineLayer::getLineMiterLimit, "nativeGetLineMiterLimit"), + METHOD(&LineLayer::getLineRoundLimit, "nativeGetLineRoundLimit"), + METHOD(&LineLayer::getLineOpacity, "nativeGetLineOpacity"), + METHOD(&LineLayer::getLineColor, "nativeGetLineColor"), + METHOD(&LineLayer::getLineTranslate, "nativeGetLineTranslate"), + METHOD(&LineLayer::getLineTranslateAnchor, "nativeGetLineTranslateAnchor"), + METHOD(&LineLayer::getLineWidth, "nativeGetLineWidth"), + METHOD(&LineLayer::getLineGapWidth, "nativeGetLineGapWidth"), + METHOD(&LineLayer::getLineOffset, "nativeGetLineOffset"), + METHOD(&LineLayer::getLineBlur, "nativeGetLineBlur"), + METHOD(&LineLayer::getLineDasharray, "nativeGetLineDasharray"), + METHOD(&LineLayer::getLinePattern, "nativeGetLinePattern")); } } // namespace android diff --git a/platform/android/src/style/layers/line_layer.hpp b/platform/android/src/style/layers/line_layer.hpp index cb53d82940..da9b564325 100644 --- a/platform/android/src/style/layers/line_layer.hpp +++ b/platform/android/src/style/layers/line_layer.hpp @@ -24,8 +24,38 @@ public: ~LineLayer(); + // Property getters + jni::Object<jni::ObjectTag> getLineCap(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getLineJoin(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getLineMiterLimit(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getLineRoundLimit(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getLineOpacity(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getLineColor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getLineTranslate(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getLineTranslateAnchor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getLineWidth(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getLineGapWidth(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getLineOffset(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getLineBlur(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getLineDasharray(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getLinePattern(jni::JNIEnv&); + jni::jobject* createJavaPeer(jni::JNIEnv&); -}; + +}; // class LineLayer } // namespace android } // namespace mbgl diff --git a/platform/android/src/style/layers/raster_layer.cpp b/platform/android/src/style/layers/raster_layer.cpp index 3da246e128..da78ccb8e3 100644 --- a/platform/android/src/style/layers/raster_layer.cpp +++ b/platform/android/src/style/layers/raster_layer.cpp @@ -4,25 +4,65 @@ #include <string> -//XXX -#include <mbgl/platform/log.hpp> +#include "../conversion/property_value.hpp" namespace mbgl { namespace android { 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))) { - mbgl::Log::Debug(mbgl::Event::JNI, "RasterLayer constructed, owning reference"); } RasterLayer::RasterLayer(mbgl::Map& map, mbgl::style::RasterLayer& coreLayer) : Layer(map, coreLayer) { - - mbgl::Log::Debug(mbgl::Event::JNI, "RasterLayer Non-owning reference constructor"); } RasterLayer::~RasterLayer() = default; + // Property getters + + jni::Object<jni::ObjectTag> RasterLayer::getRasterOpacity(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterOpacity()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> RasterLayer::getRasterHueRotate(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterHueRotate()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> RasterLayer::getRasterBrightnessMin(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterBrightnessMin()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> RasterLayer::getRasterBrightnessMax(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterBrightnessMax()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> RasterLayer::getRasterSaturation(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterSaturation()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> RasterLayer::getRasterContrast(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterContrast()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> RasterLayer::getRasterFadeDuration(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::RasterLayer>()->RasterLayer::getRasterFadeDuration()); + return jni::Object<jni::ObjectTag>(*converted); + } + jni::Class<RasterLayer> RasterLayer::javaClass; jni::jobject* RasterLayer::createJavaPeer(jni::JNIEnv& env) { @@ -31,8 +71,6 @@ namespace android { } void RasterLayer::registerNative(jni::JNIEnv& env) { - mbgl::Log::Debug(mbgl::Event::JNI, "Registering native background layer"); - //Lookup the class RasterLayer::javaClass = *jni::Class<RasterLayer>::Find(env).NewGlobalRef(env).release(); @@ -43,9 +81,14 @@ namespace android { env, RasterLayer::javaClass, "nativePtr", std::make_unique<RasterLayer, JNIEnv&, jni::String, jni::String>, "initialize", - "finalize" - ); - + "finalize", + METHOD(&RasterLayer::getRasterOpacity, "nativeGetRasterOpacity"), + METHOD(&RasterLayer::getRasterHueRotate, "nativeGetRasterHueRotate"), + METHOD(&RasterLayer::getRasterBrightnessMin, "nativeGetRasterBrightnessMin"), + METHOD(&RasterLayer::getRasterBrightnessMax, "nativeGetRasterBrightnessMax"), + METHOD(&RasterLayer::getRasterSaturation, "nativeGetRasterSaturation"), + METHOD(&RasterLayer::getRasterContrast, "nativeGetRasterContrast"), + METHOD(&RasterLayer::getRasterFadeDuration, "nativeGetRasterFadeDuration")); } } // namespace android diff --git a/platform/android/src/style/layers/raster_layer.hpp b/platform/android/src/style/layers/raster_layer.hpp index f77771631c..e59cd05f87 100644 --- a/platform/android/src/style/layers/raster_layer.hpp +++ b/platform/android/src/style/layers/raster_layer.hpp @@ -24,8 +24,24 @@ public: ~RasterLayer(); + // Property getters + jni::Object<jni::ObjectTag> getRasterOpacity(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getRasterHueRotate(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getRasterBrightnessMin(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getRasterBrightnessMax(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getRasterSaturation(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getRasterContrast(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getRasterFadeDuration(jni::JNIEnv&); + jni::jobject* createJavaPeer(jni::JNIEnv&); -}; + +}; // class RasterLayer } // namespace android } // namespace mbgl diff --git a/platform/android/src/style/layers/symbol_layer.cpp b/platform/android/src/style/layers/symbol_layer.cpp index 5de08f6511..fd69b6591f 100644 --- a/platform/android/src/style/layers/symbol_layer.cpp +++ b/platform/android/src/style/layers/symbol_layer.cpp @@ -4,25 +4,311 @@ #include <string> -//XXX -#include <mbgl/platform/log.hpp> +#include "../conversion/property_value.hpp" namespace mbgl { namespace android { 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))) { - mbgl::Log::Debug(mbgl::Event::JNI, "SymbolLayer constructed, owning reference"); } SymbolLayer::SymbolLayer(mbgl::Map& map, mbgl::style::SymbolLayer& coreLayer) : Layer(map, coreLayer) { - - mbgl::Log::Debug(mbgl::Event::JNI, "SymbolLayer Non-owning reference constructor"); } SymbolLayer::~SymbolLayer() = default; + // Property getters + + jni::Object<jni::ObjectTag> SymbolLayer::getSymbolPlacement(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getSymbolPlacement()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getSymbolSpacing(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getSymbolSpacing()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getSymbolAvoidEdges(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getSymbolAvoidEdges()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconAllowOverlap(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconAllowOverlap()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconIgnorePlacement(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconIgnorePlacement()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconOptional(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconOptional()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconRotationAlignment(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconRotationAlignment()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconSize(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconSize()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconTextFit(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconTextFit()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconTextFitPadding(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconTextFitPadding()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconImage(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconImage()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconRotate(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconRotate()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconPadding(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconPadding()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconKeepUpright(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconKeepUpright()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconOffset(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconOffset()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextPitchAlignment(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextPitchAlignment()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextRotationAlignment(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextRotationAlignment()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextField(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextField()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextFont(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextFont()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextSize(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextSize()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextMaxWidth(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextMaxWidth()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextLineHeight(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextLineHeight()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextLetterSpacing(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextLetterSpacing()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextJustify(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextJustify()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextAnchor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextAnchor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextMaxAngle(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextMaxAngle()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextRotate(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextRotate()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextPadding(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextPadding()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextKeepUpright(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextKeepUpright()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextTransform(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextTransform()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextOffset(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextOffset()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextAllowOverlap(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextAllowOverlap()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextIgnorePlacement(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextIgnorePlacement()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextOptional(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextOptional()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconOpacity(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconOpacity()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconColor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconColor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconHaloColor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconHaloColor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconHaloWidth(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconHaloWidth()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconHaloBlur(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconHaloBlur()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconTranslate(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconTranslate()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getIconTranslateAnchor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getIconTranslateAnchor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextOpacity(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextOpacity()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextColor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextColor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextHaloColor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextHaloColor()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextHaloWidth(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextHaloWidth()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextHaloBlur(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextHaloBlur()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextTranslate(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextTranslate()); + return jni::Object<jni::ObjectTag>(*converted); + } + + jni::Object<jni::ObjectTag> SymbolLayer::getTextTranslateAnchor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::SymbolLayer>()->SymbolLayer::getTextTranslateAnchor()); + return jni::Object<jni::ObjectTag>(*converted); + } + jni::Class<SymbolLayer> SymbolLayer::javaClass; jni::jobject* SymbolLayer::createJavaPeer(jni::JNIEnv& env) { @@ -31,8 +317,6 @@ namespace android { } void SymbolLayer::registerNative(jni::JNIEnv& env) { - mbgl::Log::Debug(mbgl::Event::JNI, "Registering native background layer"); - //Lookup the class SymbolLayer::javaClass = *jni::Class<SymbolLayer>::Find(env).NewGlobalRef(env).release(); @@ -43,9 +327,55 @@ namespace android { env, SymbolLayer::javaClass, "nativePtr", std::make_unique<SymbolLayer, JNIEnv&, jni::String, jni::String>, "initialize", - "finalize" - ); - + "finalize", + METHOD(&SymbolLayer::getSymbolPlacement, "nativeGetSymbolPlacement"), + METHOD(&SymbolLayer::getSymbolSpacing, "nativeGetSymbolSpacing"), + METHOD(&SymbolLayer::getSymbolAvoidEdges, "nativeGetSymbolAvoidEdges"), + METHOD(&SymbolLayer::getIconAllowOverlap, "nativeGetIconAllowOverlap"), + METHOD(&SymbolLayer::getIconIgnorePlacement, "nativeGetIconIgnorePlacement"), + METHOD(&SymbolLayer::getIconOptional, "nativeGetIconOptional"), + METHOD(&SymbolLayer::getIconRotationAlignment, "nativeGetIconRotationAlignment"), + METHOD(&SymbolLayer::getIconSize, "nativeGetIconSize"), + METHOD(&SymbolLayer::getIconTextFit, "nativeGetIconTextFit"), + METHOD(&SymbolLayer::getIconTextFitPadding, "nativeGetIconTextFitPadding"), + METHOD(&SymbolLayer::getIconImage, "nativeGetIconImage"), + METHOD(&SymbolLayer::getIconRotate, "nativeGetIconRotate"), + METHOD(&SymbolLayer::getIconPadding, "nativeGetIconPadding"), + METHOD(&SymbolLayer::getIconKeepUpright, "nativeGetIconKeepUpright"), + METHOD(&SymbolLayer::getIconOffset, "nativeGetIconOffset"), + METHOD(&SymbolLayer::getTextPitchAlignment, "nativeGetTextPitchAlignment"), + METHOD(&SymbolLayer::getTextRotationAlignment, "nativeGetTextRotationAlignment"), + METHOD(&SymbolLayer::getTextField, "nativeGetTextField"), + METHOD(&SymbolLayer::getTextFont, "nativeGetTextFont"), + METHOD(&SymbolLayer::getTextSize, "nativeGetTextSize"), + METHOD(&SymbolLayer::getTextMaxWidth, "nativeGetTextMaxWidth"), + METHOD(&SymbolLayer::getTextLineHeight, "nativeGetTextLineHeight"), + METHOD(&SymbolLayer::getTextLetterSpacing, "nativeGetTextLetterSpacing"), + METHOD(&SymbolLayer::getTextJustify, "nativeGetTextJustify"), + METHOD(&SymbolLayer::getTextAnchor, "nativeGetTextAnchor"), + METHOD(&SymbolLayer::getTextMaxAngle, "nativeGetTextMaxAngle"), + METHOD(&SymbolLayer::getTextRotate, "nativeGetTextRotate"), + METHOD(&SymbolLayer::getTextPadding, "nativeGetTextPadding"), + METHOD(&SymbolLayer::getTextKeepUpright, "nativeGetTextKeepUpright"), + METHOD(&SymbolLayer::getTextTransform, "nativeGetTextTransform"), + METHOD(&SymbolLayer::getTextOffset, "nativeGetTextOffset"), + METHOD(&SymbolLayer::getTextAllowOverlap, "nativeGetTextAllowOverlap"), + METHOD(&SymbolLayer::getTextIgnorePlacement, "nativeGetTextIgnorePlacement"), + METHOD(&SymbolLayer::getTextOptional, "nativeGetTextOptional"), + METHOD(&SymbolLayer::getIconOpacity, "nativeGetIconOpacity"), + METHOD(&SymbolLayer::getIconColor, "nativeGetIconColor"), + METHOD(&SymbolLayer::getIconHaloColor, "nativeGetIconHaloColor"), + METHOD(&SymbolLayer::getIconHaloWidth, "nativeGetIconHaloWidth"), + METHOD(&SymbolLayer::getIconHaloBlur, "nativeGetIconHaloBlur"), + METHOD(&SymbolLayer::getIconTranslate, "nativeGetIconTranslate"), + METHOD(&SymbolLayer::getIconTranslateAnchor, "nativeGetIconTranslateAnchor"), + METHOD(&SymbolLayer::getTextOpacity, "nativeGetTextOpacity"), + METHOD(&SymbolLayer::getTextColor, "nativeGetTextColor"), + METHOD(&SymbolLayer::getTextHaloColor, "nativeGetTextHaloColor"), + METHOD(&SymbolLayer::getTextHaloWidth, "nativeGetTextHaloWidth"), + METHOD(&SymbolLayer::getTextHaloBlur, "nativeGetTextHaloBlur"), + METHOD(&SymbolLayer::getTextTranslate, "nativeGetTextTranslate"), + METHOD(&SymbolLayer::getTextTranslateAnchor, "nativeGetTextTranslateAnchor")); } } // namespace android diff --git a/platform/android/src/style/layers/symbol_layer.hpp b/platform/android/src/style/layers/symbol_layer.hpp index 3f3b0e1fe6..f5165327bf 100644 --- a/platform/android/src/style/layers/symbol_layer.hpp +++ b/platform/android/src/style/layers/symbol_layer.hpp @@ -24,8 +24,106 @@ public: ~SymbolLayer(); + // Property getters + jni::Object<jni::ObjectTag> getSymbolPlacement(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getSymbolSpacing(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getSymbolAvoidEdges(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconAllowOverlap(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconIgnorePlacement(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconOptional(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconRotationAlignment(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconSize(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconTextFit(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconTextFitPadding(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconImage(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconRotate(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconPadding(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconKeepUpright(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconOffset(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextPitchAlignment(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextRotationAlignment(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextField(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextFont(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextSize(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextMaxWidth(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextLineHeight(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextLetterSpacing(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextJustify(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextAnchor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextMaxAngle(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextRotate(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextPadding(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextKeepUpright(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextTransform(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextOffset(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextAllowOverlap(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextIgnorePlacement(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextOptional(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconOpacity(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconColor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconHaloColor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconHaloWidth(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconHaloBlur(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconTranslate(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getIconTranslateAnchor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextOpacity(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextColor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextHaloColor(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextHaloWidth(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextHaloBlur(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextTranslate(jni::JNIEnv&); + + jni::Object<jni::ObjectTag> getTextTranslateAnchor(jni::JNIEnv&); + jni::jobject* createJavaPeer(jni::JNIEnv&); -}; + +}; // class SymbolLayer } // namespace android } // namespace mbgl |