[android] #5610 - Initial Runtime Style Bindings

[android] #5610 - Adjusted public api after discussion

[android] #5610 - added jni binding for NativeMapView#getLayer

[android] #5610 - Added initial test Activity

[android] #5610 - Started on NativePeer implementation for Layer

[android] #5610 - replaced low-level jni code with high-level for native getLayer

[android] 5610 - completed basic layer peer class - constructible from java and c++

[android] #5610 - removed reference that was redundant and causing the finalizer exception

[android] #5610 - Added a property peer

[android] #5610 - added value type to do type conversions - wip

[android] #5610 - simplified property conversion approach - wrapped value with jenv

[android] #5610 - added some more value conversions

[android] #5610 - Finished conversion for basic types

[android] #5610 - allow color's to be set as either an android color int or a String to support all formats in the spec

[android] #5610 - encode color ints as rgba to retain alpha channel

[android] #5610 - recalculate classes after paint property

[android] #5610 - more examples

[android] #5610 - fixed the example

[android] #5610 - cleaned up example code before continueing

[android] #5610 - added layout property example

[android] #5610 - set visibility on layer

[android] #5610 - added removeLayer and example

[android] #5610 - added more type conversions

[android] #5610 - Started on peer classes for layer implementations - WIP

[android] #5610 - First complete layer subclass peer implementation

[android] #5610 - added a little bit of structure before adding the other layer types

[android] #5610 - generate the c++ headers from the style spec

[android] #5610 - make sure the visibility is set as a string

[android] #5610 - Generate c++ layer peer class implementations from the style spec

[android] #5610 - generate java layer peer classes

[android] #5610 - cleanup comments

[android] #5610 - register all c++ peer classes with jni

[android] #5610 - addLayer

[android] #5610 - comment out broken case

[android] #5610 - Sources api - very much WIP

[android] 5610 - GeoJson source implementation and geojson conversion

[android] #5610 - cleanup add source/layer example a bit

[android] #5610 - initial filter api

[android] #5610 - Added filter api on the relevant Layer classes

[android] #5610 - raster layer is not filterable

[android] #5610 - actually make it compile

[android] #5610 - completed filter implementation

[android] #5610 - Vector and Raster Source + examples

[android] #5610 - removed superfluous interface, moved filters to the correct package

[android] #5610 - fixed comments

[android] #5610 - moved tests to the right package

[android] #5610 - hide difference between paint and layout properties in public api, make more performant set method for proeprties

[android] #5610 - fix rebase issue

1 files changed, 158 insertions, 0 deletions

diff --git a/platform/android/src/style/layers/layer.cpp b/platform/android/src/style/layers/layer.cpp
new file mode 100644
index 0000000000..aec7079698
--- /dev/null
+++ b/platform/android/src/style/layers/layer.cpp
@@ -0,0 +1,158 @@
+#include "layer.hpp"
+#include "../android_conversion.hpp"
+
+#include <jni/jni.hpp>
+
+#include <mbgl/platform/log.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/layer.hpp>
+#include <mbgl/style/conversion/source.hpp>
+
+#include <string>
+
+namespace mbgl {
+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)
+        : 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) {
+        return jni::Make<jni::String>(env, layer.getID());
+    }
+
+    std::unique_ptr<mbgl::style::Layer> Layer::releaseCoreLayer() {
+        assert(ownedLayer != nullptr);
+        return std::move(ownedLayer);
+    }
+
+    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
+        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);
+            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
+        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);
+            return;
+        }
+    }
+
+    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;
+            if(updateClasses) {
+                flags = flags | mbgl::Update::Classes;
+            }
+            map->update(flags);
+        } else {
+            mbgl::Log::Debug(mbgl::Event::JNI, "Not updating as layer is not attached to map (yet)");
+        }
+    }
+
+    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;
+
+        Result<Filter> converted = convert<Filter>(wrapped);
+        if (!converted) {
+            mbgl::Log::Error(mbgl::Event::JNI, "Error setting filter: " + converted.error().message);
+            return;
+        }
+        filter = std::move(*converted);
+
+        if (layer.is<FillLayer>()) {
+            layer.as<FillLayer>()->setFilter(filter);
+        } else if (layer.is<LineLayer>()) {
+            layer.as<LineLayer>()->setFilter(filter);
+        } else if (layer.is<SymbolLayer>()) {
+            layer.as<SymbolLayer>()->setFilter(filter);
+        } else if (layer.is<CircleLayer>()) {
+            layer.as<CircleLayer>()->setFilter(filter);
+        } else {
+            mbgl::Log::Warning(mbgl::Event::JNI, "Layer doesn't support filters");
+        }
+    }
+
+    void Layer::setSourceLayer(jni::JNIEnv& env, jni::String sourceLayer) {
+        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);
+        } else if (layer.is<LineLayer>()) {
+            layer.as<LineLayer>()->setSourceLayer(layerId);
+        } else if (layer.is<SymbolLayer>()) {
+            layer.as<SymbolLayer>()->setSourceLayer(layerId);
+        } else if (layer.is<CircleLayer>()) {
+            layer.as<CircleLayer>()->setSourceLayer(layerId);
+        } else {
+            mbgl::Log::Warning(mbgl::Event::JNI, "Layer doesn't support source layer");
+        }
+    }
+
+    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();
+
+        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+        //Register the peer
+        jni::RegisterNativePeer<Layer>(env, Layer::javaClass, "nativePtr",
+            METHOD(&Layer::getId, "nativeGetId"),
+            METHOD(&Layer::setLayoutProperty, "nativeSetLayoutProperty"),
+            METHOD(&Layer::setPaintProperty, "nativeSetPaintProperty"),
+            METHOD(&Layer::updateStyle, "nativeUpdateStyle"),
+            METHOD(&Layer::setFilter, "nativeSetFilter"),
+            METHOD(&Layer::setSourceLayer, "nativeSetSourceLayer")
+        );
+
+    }
+}
+}
\ No newline at end of file