13 files changed, 324 insertions, 69 deletions

diff --git a/platform/android/src/java/lang.hpp b/platform/android/src/java/lang.hpp
new file mode 100644
index 0000000000..dcf81a9d0c
--- /dev/null
+++ b/platform/android/src/java/lang.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+namespace mbgl {
+namespace android {
+namespace java {
+namespace lang {
+
+class Float {
+public:
+    static constexpr auto Name() { return "java/lang/Float"; };
+};
+
+class Number {
+public:
+    static constexpr auto Name() { return "java/lang/Number"; };
+};
+
+} // namespace lang
+} // namespace java
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/jni.cpp b/platform/android/src/jni.cpp
index 31fe2394f5..b6113e1d3c 100755
--- a/platform/android/src/jni.cpp
+++ b/platform/android/src/jni.cpp
@@ -14,6 +14,11 @@
 #include "bitmap.hpp"
 #include "bitmap_factory.hpp"
 #include "connectivity_listener.hpp"
+#include "style/functions/categorical_stops.hpp"
+#include "style/functions/exponential_stops.hpp"
+#include "style/functions/identity_stops.hpp"
+#include "style/functions/interval_stops.hpp"
+#include "style/functions/stop.hpp"
 #include "style/layers/layers.hpp"
 #include "style/sources/sources.hpp"
 
@@ -1780,6 +1785,11 @@ void registerNatives(JavaVM *vm) {
     BitmapFactory::registerNative(env);
     registerNativeLayers(env);
     registerNativeSources(env);
+    Stop::registerNative(env);
+    CategoricalStops::registerNative(env);
+    ExponentialStops::registerNative(env);
+    IdentityStops::registerNative(env);
+    IntervalStops::registerNative(env);
     ConnectivityListener::registerNative(env);
 
     latLngClass = &jni::FindClass(env, "com/mapbox/mapboxsdk/geometry/LatLng");
diff --git a/platform/android/src/style/conversion/function.hpp b/platform/android/src/style/conversion/function.hpp
index 104530cfe6..ad01a7afc2 100644
--- a/platform/android/src/style/conversion/function.hpp
+++ b/platform/android/src/style/conversion/function.hpp
@@ -4,6 +4,12 @@
 #include "../../conversion/conversion.hpp"
 #include "../../conversion/constant.hpp"
 #include "types.hpp"
+#include "../../java/lang.hpp"
+#include "../functions/stop.hpp"
+#include "../functions/categorical_stops.hpp"
+#include "../functions/exponential_stops.hpp"
+#include "../functions/identity_stops.hpp"
+#include "../functions/interval_stops.hpp"
 
 #include <jni/jni.hpp>
 
@@ -44,7 +50,59 @@ struct Converter<jni::jobject*, mbgl::style::CategoricalValue> {
 };
 
 template <class I, class O>
-inline jni::jobject* toFunctionStopJavaArray(jni::JNIEnv& env, std::map<I, O> value) {
+jni::Array<jni::Object<Stop>> toFunctionStopJavaArray(jni::JNIEnv& env, std::map<I, O> value) {
+
+    auto jarray = jni::Array<jni::Object<Stop>>::New(env, value.size(), Stop::javaClass);
+
+    size_t i = 0;
+    for (auto const& stop : value) {
+        jni::jobject* in = *convert<jni::jobject*, I>(env, stop.first);
+        jni::jobject* out = *convert<jni::jobject*, O>(env, stop.second);
+
+        auto jstop = Stop::New(env, jni::Object<>(in), jni::Object<>(out));
+        jarray.Set(env, i, jstop);
+
+        jni::DeleteLocalRef(env, in);
+        jni::DeleteLocalRef(env, out);
+        jni::DeleteLocalRef(env, jstop);
+
+        i++;
+    }
+
+    return jarray;
+}
+
+template <class I, class O>
+jni::Array<jni::Object<Stop>> toFunctionStopJavaArray(jni::JNIEnv& env, std::map<float, std::map<I, O>> value) {
+
+    auto jarray = jni::Array<jni::Object<Stop>>::New(env, value.size(), Stop::javaClass);
+
+    for (auto const& zoomLevelMap : value) {
+        size_t i = 0;
+        for (auto const& stop: zoomLevelMap.second) {
+            auto zoom = jni::Object<java::lang::Number>(*convert<jni::jobject*>(env, zoomLevelMap.first));
+            auto in = jni::Object<>(*convert<jni::jobject*, I>(env, stop.first));
+            auto out = jni::Object<>(*convert<jni::jobject*, O>(env, stop.second));
+            auto compositeValue = Stop::CompositeValue::New(env, zoom, in);
+
+            auto jstop = Stop::New(env, compositeValue, out);
+            jarray.Set(env, i, jstop);
+
+            jni::DeleteLocalRef(env, zoom);
+            jni::DeleteLocalRef(env, in);
+            jni::DeleteLocalRef(env, out);
+            jni::DeleteLocalRef(env, compositeValue);
+            jni::DeleteLocalRef(env, jstop);
+
+            i++;
+        }
+    }
+
+    return jarray;
+}
+
+template <class I, typename O>
+inline jni::jobject* convertCompositeStopsArray(jni::JNIEnv& env, std::map<float, std::map<I, O>> value) {
     static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/mapboxsdk/style/functions/stops/Stop")).release();
     static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "(Ljava/lang/Object;Ljava/lang/Object;)V");
 
@@ -73,85 +131,31 @@ public:
     StopsEvaluator(jni::JNIEnv& _env) : env(_env) {}
 
     jni::jobject* operator()(const mbgl::style::CategoricalStops<T> &value) const {
-        static jni::jclass* clazz = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/mapboxsdk/style/functions/stops/CategoricalStops")).release();
-        static jni::jmethodID* constructor = &jni::GetMethodID(env, *clazz, "<init>", "([Lcom/mapbox/mapboxsdk/style/functions/stops/Stop;)V");
+        return CategoricalStops::New(env, toFunctionStopJavaArray(env, value.stops)).Get();
+    }
 
-        return &jni::NewObject(env, *clazz, *constructor, toFunctionStopJavaArray(env, value.stops));
+    jni::jobject* operator()(const mbgl::style::CompositeCategoricalStops<T> &value) const {
+        return CategoricalStops::New(env, toFunctionStopJavaArray(env, value.stops)).Get();
     }
 
     jni::jobject* operator()(const mbgl::style::ExponentialStops<T> &value) const {
-        static jni::jclass* clazz = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/mapboxsdk/style/functions/stops/ExponentialStops")).release();
-        static jni::jmethodID* constructor = &jni::GetMethodID(env, *clazz, "<init>", "(Ljava/lang/Float;[Lcom/mapbox/mapboxsdk/style/functions/stops/Stop;)V");
+        return ExponentialStops::New(env, jni::Object<java::lang::Float>(*convert<jni::jobject*>(env, value.base)), toFunctionStopJavaArray(env, value.stops)).Get();
+    }
 
-        return &jni::NewObject(env, *clazz, *constructor,
-            *convert<jni::jobject*>(env, value.base),
-            toFunctionStopJavaArray(env, value.stops));
+    jni::jobject* operator()(const mbgl::style::CompositeExponentialStops<T> &value) const {
+        return ExponentialStops::New(env, jni::Object<java::lang::Float>(*convert<jni::jobject*>(env, value.base)), toFunctionStopJavaArray(env, value.stops)).Get();
     }
 
     jni::jobject* operator()(const mbgl::style::IdentityStops<T> &) const {
-        static jni::jclass* clazz = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/mapboxsdk/style/functions/stops/IdentityStops")).release();
-        static jni::jmethodID* constructor = &jni::GetMethodID(env, *clazz, "<init>", "()V");
-
-        return &jni::NewObject(env, *clazz, *constructor);
+        return IdentityStops::New(env).Get();
     }
 
     jni::jobject* operator()(const mbgl::style::IntervalStops<T> &value) const {
-        static jni::jclass* clazz = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/mapboxsdk/style/functions/stops/IntervalStops")).release();
-        static jni::jmethodID* constructor = &jni::GetMethodID(env, *clazz, "<init>", "([Lcom/mapbox/mapboxsdk/style/functions/stops/Stop;)V");
-
-        return &jni::NewObject(env, *clazz, *constructor, toFunctionStopJavaArray(env, value.stops));
+        return IntervalStops::New(env, toFunctionStopJavaArray(env, value.stops)).Get();
     }
 
-private:
-    jni::JNIEnv& env;
-};
-
-template <class T, typename X>
-inline jni::jobject* convertCompositeStopsArray(jni::JNIEnv& env, std::map<float, T> value) {
-    // Create Java Map
-    static jni::jclass* mapClass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/util/HashMap")).release();
-    static jni::jmethodID* mapConstructor = &jni::GetMethodID(env, *mapClass, "<init>", "()V");
-    static jni::jmethodID* mapPutMethod = &jni::GetMethodID(env, *mapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
-    jni::jobject& map = jni::NewObject(env, *mapClass, *mapConstructor);
-
-    // Add converted Stops for each zoom value
-    StopsEvaluator<X> evaluator(env);
-    for (auto const& entry : value) {
-        jni::jobject* zoom = *convert<jni::jobject*, float>(env, entry.first);
-        jni::jobject* stops = evaluator(entry.second);
-        jni::CallMethod<jni::jobject*>(env, &map, *mapPutMethod, zoom, stops);
-        jni::DeleteLocalRef(env, zoom);
-        jni::DeleteLocalRef(env, stops);
-    }
-
-    // Create CompositeStops from Java Map
-    static jni::jclass* compositeStopsClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/mapboxsdk/style/functions/stops/CompositeStops")).release();
-    static jni::jmethodID* compositeStopsConstructor = &jni::GetMethodID(env, *compositeStopsClass, "<init>", "(Ljava/util/Map;)V");
-    jni::jobject& compositeStops = jni::NewObject(env, *compositeStopsClass, *compositeStopsConstructor, &map);
-    jni::DeleteLocalRef(env, &map);
-
-    return &compositeStops;
-}
-
-/**
- * Conversion from core composite function stops to CompositeFunctionStops java type
- */
-template <class T>
-class CompositeStopsEvaluator {
-public:
-
-    CompositeStopsEvaluator(jni::JNIEnv& _env) : env(_env) {}
-
-    jni::jobject* operator()(const std::map<float, mbgl::style::CategoricalStops<T>> &value) const {
-        return convertCompositeStopsArray<mbgl::style::CategoricalStops<T>, T>(env, value);
-    }
-
-    jni::jobject* operator()(const std::map<float, mbgl::style::ExponentialStops<T>> &value) const {
-        return convertCompositeStopsArray<mbgl::style::ExponentialStops<T>, T>(env, value);
-    }
-
-    jni::jobject* operator()(const std::map<float, mbgl::style::IntervalStops<T>> &value) const {
-        return convertCompositeStopsArray<mbgl::style::IntervalStops<T>, T>(env, value);
+    jni::jobject* operator()(const mbgl::style::CompositeIntervalStops<T> &value) const {
+        return IntervalStops::New(env, toFunctionStopJavaArray(env, value.stops)).Get();
     }
 
 private:
@@ -201,10 +205,10 @@ struct Converter<jni::jobject*, mbgl::style::CompositeFunction<T>> {
     Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::CompositeFunction<T>& value) const {
         static jni::jclass* clazz = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/mapboxsdk/style/functions/CompositeFunction")).release();
         static jni::jmethodID* constructor = &jni::GetMethodID(env, *clazz, "<init>",
-                                                                "(Ljava/lang/Object;Ljava/lang/String;Lcom/mapbox/mapboxsdk/style/functions/stops/CompositeStops;)V");
+                                                                "(Ljava/lang/Object;Ljava/lang/String;Lcom/mapbox/mapboxsdk/style/functions/stops/Stops;)V");
 
         // Convert stops
-        CompositeStopsEvaluator<T> evaluator(env);
+        StopsEvaluator<T> evaluator(env);
         jni::jobject* stops = apply_visitor(evaluator, value.stops);
 
 
diff --git a/platform/android/src/style/functions/categorical_stops.cpp b/platform/android/src/style/functions/categorical_stops.cpp
new file mode 100644
index 0000000000..2aff9730a7
--- /dev/null
+++ b/platform/android/src/style/functions/categorical_stops.cpp
@@ -0,0 +1,18 @@
+#include "categorical_stops.hpp"
+
+namespace mbgl {
+namespace android {
+
+jni::Object<CategoricalStops> CategoricalStops::New(jni::JNIEnv& env, jni::Array<jni::Object<Stop>> stops) {
+    static auto constructor = CategoricalStops::javaClass.GetConstructor<jni::Array<jni::Object<Stop>>>(env);
+    return CategoricalStops::javaClass.New(env, constructor, stops);
+}
+
+jni::Class<CategoricalStops> CategoricalStops::javaClass;
+
+void CategoricalStops::registerNative(jni::JNIEnv& env) {
+    CategoricalStops::javaClass = *jni::Class<CategoricalStops>::Find(env).NewGlobalRef(env).release();
+}
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/functions/categorical_stops.hpp b/platform/android/src/style/functions/categorical_stops.hpp
new file mode 100644
index 0000000000..a198c8d5c9
--- /dev/null
+++ b/platform/android/src/style/functions/categorical_stops.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+#include <jni/jni.hpp>
+
+#include "stop.hpp"
+
+namespace mbgl {
+namespace android {
+
+class CategoricalStops : private mbgl::util::noncopyable {
+public:
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/functions/stops/CategoricalStops"; };
+
+    static jni::Object<CategoricalStops> New(jni::JNIEnv&, jni::Array<jni::Object<Stop>>);
+
+    static jni::Class<CategoricalStops> javaClass;
+
+    static void registerNative(jni::JNIEnv&);
+};
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/functions/exponential_stops.cpp b/platform/android/src/style/functions/exponential_stops.cpp
new file mode 100644
index 0000000000..6390a0ec35
--- /dev/null
+++ b/platform/android/src/style/functions/exponential_stops.cpp
@@ -0,0 +1,18 @@
+#include "exponential_stops.hpp"
+
+namespace mbgl {
+namespace android {
+
+jni::Object<ExponentialStops> ExponentialStops::New(jni::JNIEnv& env, jni::Object<java::lang::Float> base, jni::Array<jni::Object<Stop>> stops) {
+    static auto constructor = ExponentialStops::javaClass.GetConstructor<jni::Object<java::lang::Float>, jni::Array<jni::Object<Stop>>>(env);
+    return ExponentialStops::javaClass.New(env, constructor, base, stops);
+}
+
+jni::Class<ExponentialStops> ExponentialStops::javaClass;
+
+void ExponentialStops::registerNative(jni::JNIEnv& env) {
+    ExponentialStops::javaClass = *jni::Class<ExponentialStops>::Find(env).NewGlobalRef(env).release();
+}
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/functions/exponential_stops.hpp b/platform/android/src/style/functions/exponential_stops.hpp
new file mode 100644
index 0000000000..391d723cef
--- /dev/null
+++ b/platform/android/src/style/functions/exponential_stops.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+#include <jni/jni.hpp>
+
+#include "../../java/lang.hpp"
+#include "stop.hpp"
+
+namespace mbgl {
+namespace android {
+
+class ExponentialStops : private mbgl::util::noncopyable {
+public:
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/functions/stops/ExponentialStops"; };
+
+    static jni::Object<ExponentialStops> New(jni::JNIEnv&, jni::Object<java::lang::Float>, jni::Array<jni::Object<Stop>>);
+
+    static jni::Class<ExponentialStops> javaClass;
+
+    static void registerNative(jni::JNIEnv&);
+};
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/functions/identity_stops.cpp b/platform/android/src/style/functions/identity_stops.cpp
new file mode 100644
index 0000000000..239b0ddb88
--- /dev/null
+++ b/platform/android/src/style/functions/identity_stops.cpp
@@ -0,0 +1,18 @@
+#include "identity_stops.hpp"
+
+namespace mbgl {
+namespace android {
+
+jni::Object<IdentityStops> IdentityStops::New(jni::JNIEnv& env) {
+    static auto constructor = IdentityStops::javaClass.GetConstructor<>(env);
+    return IdentityStops::javaClass.New(env, constructor);
+}
+
+jni::Class<IdentityStops> IdentityStops::javaClass;
+
+void IdentityStops::registerNative(jni::JNIEnv& env) {
+    IdentityStops::javaClass = *jni::Class<IdentityStops>::Find(env).NewGlobalRef(env).release();
+}
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/functions/identity_stops.hpp b/platform/android/src/style/functions/identity_stops.hpp
new file mode 100644
index 0000000000..150b2135f0
--- /dev/null
+++ b/platform/android/src/style/functions/identity_stops.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class IdentityStops : private mbgl::util::noncopyable {
+public:
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/functions/stops/IdentityStops"; };
+
+    static jni::Object<IdentityStops> New(jni::JNIEnv&);
+
+    static jni::Class<IdentityStops> javaClass;
+
+    static void registerNative(jni::JNIEnv&);
+};
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/functions/interval_stops.cpp b/platform/android/src/style/functions/interval_stops.cpp
new file mode 100644
index 0000000000..c3d9b6513f
--- /dev/null
+++ b/platform/android/src/style/functions/interval_stops.cpp
@@ -0,0 +1,18 @@
+#include "interval_stops.hpp"
+
+namespace mbgl {
+namespace android {
+
+jni::Object<IntervalStops> IntervalStops::New(jni::JNIEnv& env, jni::Array<jni::Object<Stop>> stops) {
+    static auto constructor = IntervalStops::javaClass.GetConstructor<jni::Array<jni::Object<Stop>>>(env);
+    return IntervalStops::javaClass.New(env, constructor, stops);
+}
+
+jni::Class<IntervalStops> IntervalStops::javaClass;
+
+void IntervalStops::registerNative(jni::JNIEnv& env) {
+    IntervalStops::javaClass = *jni::Class<IntervalStops>::Find(env).NewGlobalRef(env).release();
+}
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/functions/interval_stops.hpp b/platform/android/src/style/functions/interval_stops.hpp
new file mode 100644
index 0000000000..e3f75159cf
--- /dev/null
+++ b/platform/android/src/style/functions/interval_stops.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+#include <jni/jni.hpp>
+
+#include "stop.hpp"
+
+namespace mbgl {
+namespace android {
+
+class IntervalStops : private mbgl::util::noncopyable {
+public:
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/functions/stops/IntervalStops"; };
+
+    static jni::Object<IntervalStops> New(jni::JNIEnv&, jni::Array<jni::Object<Stop>>);
+
+    static jni::Class<IntervalStops> javaClass;
+
+    static void registerNative(jni::JNIEnv&);
+};
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/functions/stop.cpp b/platform/android/src/style/functions/stop.cpp
new file mode 100644
index 0000000000..f9ed4b7368
--- /dev/null
+++ b/platform/android/src/style/functions/stop.cpp
@@ -0,0 +1,21 @@
+#include "interval_stops.hpp"
+
+namespace mbgl {
+namespace android {
+
+jni::Object<Stop::CompositeValue> Stop::CompositeValue::New(jni::JNIEnv& env, jni::Object<java::lang::Number> zoom, jni::Object<> value) {
+    static auto constructor = Stop::CompositeValue::javaClass.GetConstructor<jni::Object<java::lang::Number>, jni::Object<>>(env);
+    return Stop::CompositeValue::javaClass.New(env, constructor, zoom, value);
+}
+
+jni::Class<Stop> Stop::javaClass;
+
+jni::Class<Stop::CompositeValue> Stop::CompositeValue::javaClass;
+
+void Stop::registerNative(jni::JNIEnv& env) {
+    Stop::javaClass = *jni::Class<Stop>::Find(env).NewGlobalRef(env).release();
+    Stop::CompositeValue::javaClass = *jni::Class<Stop::CompositeValue>::Find(env).NewGlobalRef(env).release();
+}
+
+} // namespace android
+} // namespace mbgl
diff --git a/platform/android/src/style/functions/stop.hpp b/platform/android/src/style/functions/stop.hpp
new file mode 100644
index 0000000000..7c697db65d
--- /dev/null
+++ b/platform/android/src/style/functions/stop.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <mbgl/util/noncopyable.hpp>
+#include <jni/jni.hpp>
+
+#include "../../java/lang.hpp"
+
+namespace mbgl {
+namespace android {
+
+class Stop : private mbgl::util::noncopyable {
+public:
+    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/functions/stops/Stop"; };
+
+    template<class I, class O>
+    static jni::Object<Stop> New(jni::JNIEnv& env, jni::Object<I> in, jni::Object<O> out) {
+        static auto constructor = Stop::javaClass.GetConstructor<jni::Object<>, jni::Object<>>(env);
+        return Stop::javaClass.New(env, constructor, (jni::Object<>) in, (jni::Object<>) out);
+    }
+
+    static jni::Class<Stop> javaClass;
+
+    static void registerNative(jni::JNIEnv&);
+
+    class CompositeValue : private mbgl::util::noncopyable {
+    public:
+        static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/functions/stops/Stop$CompositeValue"; };
+
+        static jni::Object<Stop::CompositeValue> New(jni::JNIEnv&, jni::Object<java::lang::Number>, jni::Object<>);
+
+        static jni::Class<Stop::CompositeValue> javaClass;
+    };
+};
+
+} // namespace android
+} // namespace mbgl