9 files changed, 506 insertions, 0 deletions
diff --git a/platform/android/src/style/conversion/position.hpp b/platform/android/src/style/conversion/position.hpp
new file mode 100644
index 0000000000..f32a892c0c
--- /dev/null
+++ b/platform/android/src/style/conversion/position.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "../../conversion/conversion.hpp"
+
+#include <jni/jni.hpp>
+#include <mbgl/style/position.hpp>
+#include "../../jni/local_object.hpp"
+#include "../position.hpp"
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+template<>
+struct Converter<jni::Object<Position>, mbgl::style::Position> {
+    Result<jni::Object<Position>> operator()(jni::JNIEnv &env, const mbgl::style::Position &value) const {
+        std::array<float, 3> cartPosition = value.getSpherical();
+        return Position::fromPosition(env, cartPosition[0], cartPosition[1], cartPosition[2]);
+    }
+};
+
+template<>
+struct Converter<mbgl::style::Position, jni::Object<Position>> {
+    Result<mbgl::style::Position> operator()(jni::JNIEnv &env, const jni::Object<Position> &value) const {
+        float radialCoordinate = Position::getRadialCoordinate(env, value);
+        float azimuthalAngle = Position::getAzimuthalAngle(env, value);
+        float polarAngle = Position::getPolarAngle(env, value);
+        std::array<float, 3> cartPosition {{radialCoordinate, azimuthalAngle, polarAngle}};
+        mbgl::style::Position position{};
+        position.set(cartPosition);
+        return position;
+    }
+};
+
+}
+}
+}
+\ No newline at end of file
diff --git a/platform/android/src/style/conversion/types.hpp b/platform/android/src/style/conversion/types.hpp
index d9921e582e..a00f668c24 100644
--- a/platform/android/src/style/conversion/types.hpp
+++ b/platform/android/src/style/conversion/types.hpp
@@ -92,6 +92,13 @@ struct Converter<jni::jobject*, mbgl::style::CirclePitchScaleType> {
     }
 };
 
+template <>
+struct Converter<jni::jobject*, mbgl::style::LightAnchorType> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::LightAnchorType& value) const {
+        return convert<jni::jobject*, std::string>(env, toString(value));
+    }
+};
+
 
 } // namespace conversion
 } // namespace android
diff --git a/platform/android/src/style/conversion/types_string_values.hpp b/platform/android/src/style/conversion/types_string_values.hpp
index e3108fdf5b..e96de3b01e 100644
--- a/platform/android/src/style/conversion/types_string_values.hpp
+++ b/platform/android/src/style/conversion/types_string_values.hpp
@@ -206,6 +206,20 @@ namespace conversion {
         }
     }
 
+    // anchor
+    inline std::string toString(mbgl::style::LightAnchorType value) {
+        switch (value) {
+          case mbgl::style::LightAnchorType::Map:
+            return "map";
+            break;
+          case mbgl::style::LightAnchorType::Viewport:
+            return "viewport";
+            break;
+          default:
+            throw std::runtime_error("Not implemented");
+        }
+    }
+
 
 } // namespace conversion
 } // namespace android
diff --git a/platform/android/src/style/light.cpp b/platform/android/src/style/light.cpp
new file mode 100644
index 0000000000..71f1cb076e
--- /dev/null
+++ b/platform/android/src/style/light.cpp
@@ -0,0 +1,146 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include <mbgl/map/map.hpp>
+#include "light.hpp"
+#include "conversion/transition_options.hpp"
+#include "conversion/position.hpp"
+
+namespace mbgl {
+namespace android {
+
+Light::Light(mbgl::Map& coreMap, mbgl::style::Light& coreLight)
+    : light(coreLight) , map(&coreMap) {
+}
+
+static Light* initializeLightPeer(mbgl::Map& map, mbgl::style::Light& coreLight) {
+    return new Light(map, coreLight);
+}
+
+jni::jobject* Light::createJavaLightPeer(jni::JNIEnv& env, Map& map, mbgl::style::Light& coreLight) {
+    std::unique_ptr<Light> peerLight = std::unique_ptr<Light>(initializeLightPeer(map, coreLight));
+    jni::jobject* result = peerLight->createJavaPeer(env);
+    peerLight.release();
+    return result;
+}
+
+jni::Class<Light> Light::javaClass;
+
+jni::jobject* Light::createJavaPeer(jni::JNIEnv& env) {
+    static auto constructor = Light::javaClass.template GetConstructor<jni::jlong>(env);
+    return Light::javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+}
+
+void Light::setAnchor(jni::JNIEnv& env, jni::String property) {
+    std::string anchorStr = jni::Make<std::string>(env, property);
+    if (anchorStr.compare("map") == 0) {
+        light.setAnchor(LightAnchorType::Map);
+    } else if (anchorStr.compare("viewport") == 0) {
+        light.setAnchor(LightAnchorType::Viewport);
+    }
+}
+
+jni::String Light::getAnchor(jni::JNIEnv& env) {
+    auto anchorType = light.getAnchor();
+    if (anchorType == LightAnchorType::Map) {
+        return jni::Make<jni::String>(env, "map");
+    } else {
+        return jni::Make<jni::String>(env, "viewport");
+    }
+}
+
+void Light::setPosition(jni::JNIEnv& env, jni::Object<Position> jposition) {
+    using namespace mbgl::android::conversion;
+    auto position = *convert<mbgl::style::Position>(env, jposition);
+    light.setPosition(position);
+}
+
+jni::Object<Position> Light::getPosition(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    mbgl::style::Position position = light.getPosition().asConstant();
+    return *convert<jni::Object<Position>>(env, position);
+}
+
+jni::Object<TransitionOptions> Light::getPositionTransition(jni::JNIEnv& env) {
+   using namespace mbgl::android::conversion;
+   mbgl::style::TransitionOptions options = light.getPositionTransition();
+   return *convert<jni::Object<TransitionOptions>>(env, options);
+}
+
+void Light::setPositionTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+   mbgl::style::TransitionOptions options;
+   options.duration.emplace(mbgl::Milliseconds(duration));
+   options.delay.emplace(mbgl::Milliseconds(delay));
+   light.setPositionTransition(options);
+}
+
+void Light::setColor(jni::JNIEnv& env, jni::String property) {
+    auto color = Color::parse(jni::Make<std::string>(env, property));
+    if (color) {
+        light.setColor(color.value());
+    }
+}
+
+jni::String Light::getColor(jni::JNIEnv &env) {
+    auto color = light.getColor().asConstant();
+    return jni::Make<jni::String>(env, color.stringify());
+}
+
+jni::Object<TransitionOptions> Light::getColorTransition(jni::JNIEnv& env) {
+   using namespace mbgl::android::conversion;
+   mbgl::style::TransitionOptions options = light.getColorTransition();
+   return *convert<jni::Object<TransitionOptions>>(env, options);
+}
+
+void Light::setColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+   mbgl::style::TransitionOptions options;
+   options.duration.emplace(mbgl::Milliseconds(duration));
+   options.delay.emplace(mbgl::Milliseconds(delay));
+   light.setColorTransition(options);
+}
+
+void Light::setIntensity(jni::JNIEnv&, jni::jfloat property) {
+    light.setIntensity(property);
+}
+
+jni::jfloat Light::getIntensity(jni::JNIEnv&) {
+    return light.getIntensity().asConstant();
+}
+
+jni::Object<TransitionOptions> Light::getIntensityTransition(jni::JNIEnv& env) {
+   using namespace mbgl::android::conversion;
+   mbgl::style::TransitionOptions options = light.getIntensityTransition();
+   return *convert<jni::Object<TransitionOptions>>(env, options);
+}
+
+void Light::setIntensityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+   mbgl::style::TransitionOptions options;
+   options.duration.emplace(mbgl::Milliseconds(duration));
+   options.delay.emplace(mbgl::Milliseconds(delay));
+   light.setIntensityTransition(options);
+}
+
+void Light::registerNative(jni::JNIEnv& env) {
+    // Lookup the class
+    Light::javaClass = *jni::Class<Light>::Find(env).NewGlobalRef(env).release();
+
+#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+    // Register the peer
+    jni::RegisterNativePeer<Light>(env, Light::javaClass, "nativePtr",
+    METHOD(&Light::getAnchor, "nativeGetAnchor"),
+    METHOD(&Light::setAnchor, "nativeSetAnchor"),
+    METHOD(&Light::getPositionTransition, "nativeGetPositionTransition"),
+    METHOD(&Light::setPositionTransition, "nativeSetPositionTransition"),
+    METHOD(&Light::getPosition, "nativeGetPosition"),
+    METHOD(&Light::setPosition, "nativeSetPosition"),
+    METHOD(&Light::getColorTransition, "nativeGetColorTransition"),
+    METHOD(&Light::setColorTransition, "nativeSetColorTransition"),
+    METHOD(&Light::getColor, "nativeGetColor"),
+    METHOD(&Light::setColor, "nativeSetColor"),
+    METHOD(&Light::getIntensityTransition, "nativeGetIntensityTransition"),
+    METHOD(&Light::setIntensityTransition, "nativeSetIntensityTransition"),
+    METHOD(&Light::getIntensity, "nativeGetIntensity"),
+    METHOD(&Light::setIntensity, "nativeSetIntensity"));
+}
+
+} // namespace android
+} // namespace mb
diff --git a/platform/android/src/style/light.cpp.ejs b/platform/android/src/style/light.cpp.ejs
new file mode 100644
index 0000000000..17f0bba09d
--- /dev/null
+++ b/platform/android/src/style/light.cpp.ejs
@@ -0,0 +1,123 @@
+<%
+  const properties = locals.properties;
+-%>
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#include <mbgl/map/map.hpp>
+#include "light.hpp"
+#include "conversion/transition_options.hpp"
+#include "conversion/position.hpp"
+
+namespace mbgl {
+namespace android {
+
+Light::Light(mbgl::Map& coreMap, mbgl::style::Light& coreLight)
+    : light(coreLight) , map(&coreMap) {
+}
+
+static Light* initializeLightPeer(mbgl::Map& map, mbgl::style::Light& coreLight) {
+    return new Light(map, coreLight);
+}
+
+jni::jobject* Light::createJavaLightPeer(jni::JNIEnv& env, Map& map, mbgl::style::Light& coreLight) {
+    std::unique_ptr<Light> peerLight = std::unique_ptr<Light>(initializeLightPeer(map, coreLight));
+    jni::jobject* result = peerLight->createJavaPeer(env);
+    peerLight.release();
+    return result;
+}
+
+jni::Class<Light> Light::javaClass;
+
+jni::jobject* Light::createJavaPeer(jni::JNIEnv& env) {
+    static auto constructor = Light::javaClass.template GetConstructor<jni::jlong>(env);
+    return Light::javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
+}
+
+<% for (const property of properties) { -%>
+<% if (property.name == "position") { -%>
+void Light::set<%- camelize(property.name) %>(jni::JNIEnv& env, jni::Object<<%- camelize(property.name) %>> j<%- property.name %>) {
+    using namespace mbgl::android::conversion;
+    auto position = *convert<mbgl::style::<%- camelize(property.name) %>>(env, jposition);
+    light.set<%- camelize(property.name) %>(<%- property.name %>);
+}
+
+jni::Object<Position> Light::get<%- camelize(property.name) %>(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    mbgl::style::<%- camelize(property.name) %> <%- property.name %> = light.get<%- camelize(property.name) %>().asConstant();
+    return *convert<jni::Object<<%- camelize(property.name) %>>>(env, <%- property.name %>);
+}
+<% } else { -%>
+<% if(property.name == "color") {-%>
+void Light::set<%- camelize(property.name) %>(jni::JNIEnv& env, jni::<%- propertyJNIType(property) %> property) {
+    auto color = Color::parse(jni::Make<std::string>(env, property));
+    if (color) {
+        light.set<%- camelize(property.name) %>(color.value());
+    }
+}
+
+jni::String Light::get<%- camelize(property.name) %>(jni::JNIEnv &env) {
+    auto color = light.get<%- camelize(property.name) %>().asConstant();
+    return jni::Make<jni::String>(env, color.stringify());
+}
+<% } else if(property.name == "anchor"){ -%>
+void Light::set<%- camelize(property.name) %>(jni::JNIEnv& env, jni::<%- propertyJNIType(property) %> property) {
+    std::string anchorStr = jni::Make<std::string>(env, property);
+    if (anchorStr.compare("map") == 0) {
+        light.setAnchor(LightAnchorType::Map);
+    } else if (anchorStr.compare("viewport") == 0) {
+        light.setAnchor(LightAnchorType::Viewport);
+    }
+}
+
+jni::String Light::getAnchor(jni::JNIEnv& env) {
+    auto anchorType = light.getAnchor();
+    if (anchorType == LightAnchorType::Map) {
+        return jni::Make<jni::String>(env, "map");
+    } else {
+        return jni::Make<jni::String>(env, "viewport");
+    }
+}
+<% } else { -%>
+void Light::set<%- camelize(property.name) %>(jni::JNIEnv&, jni::<%- propertyJNIType(property) %> property) {
+    light.set<%- camelize(property.name) %>(property);
+}
+
+jni::<%- propertyJNIType(property) %> Light::get<%- camelize(property.name) %>(jni::JNIEnv&) {
+    return light.get<%- camelize(property.name) %>().asConstant();
+}
+<% } -%>
+<% } -%>
+
+<% if (property.transition) { -%>
+jni::Object<TransitionOptions> Light::get<%- camelize(property.name) %>Transition(jni::JNIEnv& env) {
+   using namespace mbgl::android::conversion;
+   mbgl::style::TransitionOptions options = light.get<%- camelize(property.name) %>Transition();
+   return *convert<jni::Object<TransitionOptions>>(env, options);
+}
+
+void Light::set<%- camelize(property.name) %>Transition(jni::JNIEnv&, jlong duration, jlong delay) {
+   mbgl::style::TransitionOptions options;
+   options.duration.emplace(mbgl::Milliseconds(duration));
+   options.delay.emplace(mbgl::Milliseconds(delay));
+   light.set<%- camelize(property.name) %>Transition(options);
+}
+
+<% } -%>
+<% } -%>
+void Light::registerNative(jni::JNIEnv& env) {
+    // Lookup the class
+    Light::javaClass = *jni::Class<Light>::Find(env).NewGlobalRef(env).release();
+
+#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+    // Register the peer
+    jni::RegisterNativePeer<Light>(env, Light::javaClass, "nativePtr",<% for(var i = 0; i < properties.length; i++) {%>
+<% if (properties[i].transition) { -%>
+    METHOD(&Light::get<%- camelize(properties[i].name) %>Transition, "nativeGet<%- camelize(properties[i].name) %>Transition"),
+    METHOD(&Light::set<%- camelize(properties[i].name) %>Transition, "nativeSet<%- camelize(properties[i].name) %>Transition"),
+<% } -%>
+    METHOD(&Light::get<%- camelize(properties[i].name) %>, "nativeGet<%- camelize(properties[i].name) %>"),
+    METHOD(&Light::set<%- camelize(properties[i].name) %>, "nativeSet<%- camelize(properties[i].name) %>")<% if(i != (properties.length -1)) {-%>,<% } -%><% } -%>);
+}
+
+} // namespace android
+} // namespace mb
diff --git a/platform/android/src/style/light.hpp b/platform/android/src/style/light.hpp
new file mode 100644
index 0000000000..2c314067be
--- /dev/null
+++ b/platform/android/src/style/light.hpp
@@ -0,0 +1,57 @@
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+
+#include <jni/jni.hpp>
+#include <mbgl/style/light.hpp>
+#include "transition_options.hpp"
+#include "position.hpp"
+#include <mbgl/style/types.hpp>
+#include <mbgl/style/property_value.hpp>
+
+namespace mbgl {
+namespace android {
+
+using namespace style;
+
+class Light : private mbgl::util::noncopyable {
+public:
+
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/light/Light"; };
+
+    static jni::Class<Light> javaClass;
+
+    static void registerNative(jni::JNIEnv&);
+
+    static jni::jobject* createJavaLightPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Light&);
+
+    Light(mbgl::Map&, mbgl::style::Light&);
+
+    void setAnchor(jni::JNIEnv&, jni::String);
+    jni::String getAnchor(jni::JNIEnv&);
+    void setPosition(jni::JNIEnv&, jni::Object<Position>);
+    jni::Object<Position> getPosition(jni::JNIEnv&);
+    void setPositionTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Object<TransitionOptions> getPositionTransition(jni::JNIEnv&);
+    void setColor(jni::JNIEnv&, jni::String);
+    jni::String getColor(jni::JNIEnv&);
+    void setColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Object<TransitionOptions> getColorTransition(jni::JNIEnv&);
+    void setIntensity(jni::JNIEnv&, jni::jfloat);
+    jni::jfloat getIntensity(jni::JNIEnv&);
+    void setIntensityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Object<TransitionOptions> getIntensityTransition(jni::JNIEnv&);
+    jni::jobject* createJavaPeer(jni::JNIEnv&);
+
+protected:
+
+    // Raw reference to the light
+    mbgl::style::Light& light;
+
+    // Map is set when the light is retrieved
+    mbgl::Map* map;
+};
+} // namespace android
+} // namespace mbgl
+\ No newline at end of file
diff --git a/platform/android/src/style/light.hpp.ejs b/platform/android/src/style/light.hpp.ejs
new file mode 100644
index 0000000000..18f961b9e0
--- /dev/null
+++ b/platform/android/src/style/light.hpp.ejs
@@ -0,0 +1,59 @@
+<%
+  const properties = locals.properties;
+-%>
+// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
+
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+
+#include <jni/jni.hpp>
+#include <mbgl/style/light.hpp>
+#include "transition_options.hpp"
+#include "position.hpp"
+#include <mbgl/style/types.hpp>
+#include <mbgl/style/property_value.hpp>
+
+namespace mbgl {
+namespace android {
+
+using namespace style;
+
+class Light : private mbgl::util::noncopyable {
+public:
+
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/light/Light"; };
+
+    static jni::Class<Light> javaClass;
+
+    static void registerNative(jni::JNIEnv&);
+
+    static jni::jobject* createJavaLightPeer(jni::JNIEnv&, mbgl::Map&, mbgl::style::Light&);
+
+    Light(mbgl::Map&, mbgl::style::Light&);
+
+<% for (const property of properties) { -%>
+<% if (property.name=="position") {-%>
+    void set<%- camelize(property.name) %>(jni::JNIEnv&, jni::Object<Position>);
+    jni::Object<<%- camelize(property.name) %>> get<%- camelize(property.name) %>(jni::JNIEnv&);
+<% } else { -%>
+    void set<%- camelize(property.name) %>(jni::JNIEnv&, jni::<%- propertyJNIType(property) %>);
+    jni::<%- propertyJNIType(property) %> get<%- camelize(property.name) %>(jni::JNIEnv&);
+<% } -%>
+<% if (property.transition) { -%>
+    void set<%- camelize(property.name) %>Transition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Object<TransitionOptions> get<%- camelize(property.name) %>Transition(jni::JNIEnv&);
+<% } -%>
+<% } -%>
+    jni::jobject* createJavaPeer(jni::JNIEnv&);
+
+protected:
+
+    // Raw reference to the light
+    mbgl::style::Light& light;
+
+    // Map is set when the light is retrieved
+    mbgl::Map* map;
+};
+} // namespace android
+} // namespace mbgl
+\ No newline at end of file
diff --git a/platform/android/src/style/position.cpp b/platform/android/src/style/position.cpp
new file mode 100644
index 0000000000..0bbcefcbcd
--- /dev/null
+++ b/platform/android/src/style/position.cpp
@@ -0,0 +1,34 @@
+#include "position.hpp"
+
+namespace mbgl {
+namespace android {
+
+jni::Object<Position> Position::fromPosition(jni::JNIEnv& env, jfloat radialCoordinate, jfloat azimuthalAngle, jfloat polarAngle) {
+    static auto method = Position::javaClass.GetStaticMethod<jni::Object<Position> (jfloat, jfloat, jfloat)>(env, "fromPosition");
+    return Position::javaClass.Call(env, method, radialCoordinate, azimuthalAngle, polarAngle);
+}
+
+void Position::registerNative(jni::JNIEnv& env) {
+    // Lookup the class
+    Position::javaClass = *jni::Class<Position>::Find(env).NewGlobalRef(env).release();
+}
+
+jni::Class<Position> Position::javaClass;
+
+float Position::getRadialCoordinate(jni::JNIEnv& env, jni::Object<Position> position){
+    static auto field = Position::javaClass.GetField<jfloat>(env, "radialCoordinate");
+    return position.Get(env, field);
+}
+
+float Position::getAzimuthalAngle(jni::JNIEnv& env, jni::Object<Position> position){
+    static auto field = Position::javaClass.GetField<jfloat>(env, "azimuthalAngle");
+    return position.Get(env, field);
+}
+
+float Position::getPolarAngle(jni::JNIEnv& env, jni::Object<Position> position){
+    static auto field = Position::javaClass.GetField<jfloat>(env, "polarAngle");
+    return position.Get(env, field);
+}
+
+} // namespace andr[oid
+} // namespace mbgl
+\ No newline at end of file
diff --git a/platform/android/src/style/position.hpp b/platform/android/src/style/position.hpp
new file mode 100644
index 0000000000..4aafa853db
--- /dev/null
+++ b/platform/android/src/style/position.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class Position : private mbgl::util::noncopyable {
+public:
+
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/light/Position"; };
+
+    static jni::Object<Position> fromPosition(jni::JNIEnv&, jfloat, jfloat, jfloat);
+
+    static jni::Class<Position> javaClass;
+
+    static void registerNative(jni::JNIEnv&);
+
+    static float getRadialCoordinate(jni::JNIEnv&, jni::Object<Position>);
+    static float getAzimuthalAngle(jni::JNIEnv&, jni::Object<Position>);
+    static float getPolarAngle(jni::JNIEnv&, jni::Object<Position>);
+
+};
+
+
+} // namespace android
+} // namespace mbgl
+\ No newline at end of file