[android] #5869 - visible feature querying

3 files changed, 105 insertions, 1 deletions

diff --git a/platform/android/src/conversion/collection.hpp b/platform/android/src/conversion/collection.hpp
new file mode 100644
index 0000000000..4256d5f969
--- /dev/null
+++ b/platform/android/src/conversion/collection.hpp
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "conversion.hpp"
+#include "constant.hpp"
+
+#include <mbgl/util/optional.hpp>
+#include <jni/jni.hpp>
+
+#include <vector>
+
+namespace mbgl {
+namespace android {
+namespace conversion {
+
+/**
+ * Convert jarray -> ArrayList
+ */
+template <class T>
+inline jni::jobject* toArrayList(JNIEnv& env, jni::jarray<T>& array) {
+    static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/util/Arrays")).release();
+    static jni::jmethodID* asList = &jni::GetStaticMethodID(env, *javaClass, "asList", "([Ljava/lang/Object;)Ljava/util/List;");
+    return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *asList, array));
+}
+
+// Java -> C++
+
+
+inline std::vector<std::string> toVector(JNIEnv& env, jni::jarray<jni::jobject>& array) {
+    std::vector<std::string> vector;
+    std::size_t len = jni::GetArrayLength(env, array);
+
+    for (std::size_t i = 0; i < len; i++) {
+        jni::jstring* jstr = reinterpret_cast<jni::jstring*>(jni::GetObjectArrayElement(env, array, i));
+        vector.push_back(*convert<std::string, jni::String>(env, jni::String(jstr)));
+    }
+
+    return vector;
+}
+
+}
+}
+}
diff --git a/platform/android/src/conversion/constant.hpp b/platform/android/src/conversion/constant.hpp
index 9a570d3717..f1a8171b99 100644
--- a/platform/android/src/conversion/constant.hpp
+++ b/platform/android/src/conversion/constant.hpp
@@ -24,6 +24,13 @@ struct Converter<jni::jobject*, bool> {
 };
 
 template <>
+struct Converter<jni::jboolean, bool> {
+    Result<jni::jboolean> operator()(jni::JNIEnv&, const bool& value) const {
+        return {(jni::jboolean) value};
+    }
+};
+
+template <>
 struct Converter<jni::jobject*, float> {
     Result<jni::jobject*> operator()(jni::JNIEnv& env, const float& value) const {
         static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/lang/Float")).release();
@@ -33,6 +40,45 @@ struct Converter<jni::jobject*, float> {
 };
 
 template <>
+struct Converter<jni::jfloat, float> {
+    Result<jni::jfloat> operator()(jni::JNIEnv&, const float& value) const {
+        return {(jni::jfloat) value};
+    }
+};
+
+
+template <>
+struct Converter<jni::jobject*, double> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const double& value) const {
+        static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/lang/Double")).release();
+        static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "(D)V");
+        return {&jni::NewObject(env, *javaClass, *constructor, (jfloat) value)};
+    }
+};
+
+template <>
+struct Converter<jni::jdouble, float> {
+    Result<jni::jdouble> operator()(jni::JNIEnv&, const double& value) const {
+        return {(jni::jdouble) value};
+    }
+};
+
+/**
+ * All integrals. java is limited to 64 bit signed, so...
+ * TODO: use BigDecimal for > 64 / unsigned?
+ */
+template<typename T>
+struct Converter<jni::jobject*, T, typename std::enable_if<std::is_integral<T>::value>::type> {
+    Result<jni::jobject*> operator()(jni::JNIEnv& env, const T& value) const {
+        static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/lang/Long")).release();
+        static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "(J)V");
+        return {&jni::NewObject(env, *javaClass, *constructor, (jlong) value)};
+    }
+};
+
+//TODO: convert integral types to primitive jni types
+
+template <>
 struct Converter<jni::jobject*, std::string> {
     Result<jni::jobject*> operator()(jni::JNIEnv& env, const std::string& value) const {
         return {jni::Make<jni::String>(env, value).Get()};
@@ -40,6 +86,13 @@ struct Converter<jni::jobject*, std::string> {
 };
 
 template <>
+struct Converter<jni::jstring*, std::string> {
+    Result<jni::jstring*> operator()(jni::JNIEnv& env, const std::string& value) const {
+        return {jni::Make<jni::String>(env, value).Get()};
+    }
+};
+
+template <>
 struct Converter<jni::jobject*, Color> {
     Result<jni::jobject*> operator()(jni::JNIEnv& env, const Color& value) const {
         std::stringstream sstream;
@@ -90,6 +143,15 @@ struct Converter<jni::jobject*, std::vector<float>> {
     }
 };
 
+// Java -> C++
+
+template <>
+struct Converter<std::string, jni::String> {
+    Result<std::string> operator()(jni::JNIEnv& env, const jni::String& value) const {
+        return { jni::Make<std::string>(env, value) };
+    }
+};
+
 } // namespace conversion
 } // namespace style
 } // namespace mbgl
diff --git a/platform/android/src/conversion/conversion.hpp b/platform/android/src/conversion/conversion.hpp
index ea8a31bcf2..1277f3f67e 100644
--- a/platform/android/src/conversion/conversion.hpp
+++ b/platform/android/src/conversion/conversion.hpp
@@ -37,7 +37,7 @@ public:
     }
 };
 
-template <class T, class V>
+template <class T, class V, class Enable = void>
 struct Converter;
 
 template <class T, typename V, class...Args>