Merge remote-tracking branch 'origin' into bwg-vs2017upstream/bwg-vs2017

# Conflicts:
#	cmake/mason-dependencies.cmake

8 files changed, 116 insertions, 309 deletions

diff --git a/platform/android/src/gson/json_array.cpp b/platform/android/src/gson/json_array.cpp
index e8852d77e9..8ffa658b76 100644
--- a/platform/android/src/gson/json_array.cpp
+++ b/platform/android/src/gson/json_array.cpp
@@ -1,32 +1,31 @@
 #include "json_array.hpp"
-
 #include "json_element.hpp"
 
 namespace mbgl {
 namespace android {
 namespace gson {
 
-jni::Object<JsonArray> JsonArray::New(jni::JNIEnv& env, const std::vector<mapbox::geometry::value>& values){
-    static auto constructor = JsonArray::javaClass.GetConstructor(env);
-    static auto addMethod = JsonArray::javaClass.GetMethod<void (jni::Object<JsonElement>)>(env, "add");
+jni::Local<jni::Object<JsonArray>> JsonArray::New(jni::JNIEnv& env, const std::vector<mbgl::Value>& values){
+    static auto& javaClass = jni::Class<JsonArray>::Singleton(env);
+    static auto constructor = javaClass.GetConstructor(env);
+    static auto addMethod = javaClass.GetMethod<void (jni::Object<JsonElement>)>(env, "add");
 
-    auto jsonArray = JsonArray::javaClass.New(env, constructor);
+    auto jsonArray = javaClass.New(env, constructor);
 
     for (const auto &v : values) {
-        auto jsonElement = JsonElement::New(env, v);
-        jsonArray.Call(env, addMethod, jsonElement);
-        jni::DeleteLocalRef(env, jsonElement);
+        jsonArray.Call(env, addMethod, JsonElement::New(env, v));
     }
 
     return jsonArray;
 }
 
-std::vector<mapbox::geometry::value> JsonArray::convert(jni::JNIEnv& env, const jni::Object<JsonArray> jsonArray) {
-    std::vector<mapbox::geometry::value> values;
+std::vector<mbgl::Value> JsonArray::convert(jni::JNIEnv& env, const jni::Object<JsonArray>& jsonArray) {
+    std::vector<mbgl::Value> values;
 
     if (jsonArray) {
-        static auto getMethod = JsonArray::javaClass.GetMethod<jni::Object<JsonElement> (jni::jint)>(env, "get");
-        static auto sizeMethod = JsonArray::javaClass.GetMethod<jni::jint ()>(env, "size");
+        static auto& javaClass = jni::Class<JsonArray>::Singleton(env);
+        static auto getMethod = javaClass.GetMethod<jni::Object<JsonElement> (jni::jint)>(env, "get");
+        static auto sizeMethod = javaClass.GetMethod<jni::jint ()>(env, "size");
 
         int size = jsonArray.Call(env, sizeMethod);
         values.reserve(uint(size));
@@ -36,7 +35,6 @@ std::vector<mapbox::geometry::value> JsonArray::convert(jni::JNIEnv& env, const
             if (entry) {
                 values.push_back(JsonElement::convert(env, entry));
             }
-            jni::DeleteLocalRef(env, entry);
         }
     }
 
@@ -44,12 +42,9 @@ std::vector<mapbox::geometry::value> JsonArray::convert(jni::JNIEnv& env, const
 }
 
 void JsonArray::registerNative(jni::JNIEnv& env) {
-    // Lookup the class
-    javaClass = *jni::Class<JsonArray>::Find(env).NewGlobalRef(env).release();
+    jni::Class<JsonArray>::Singleton(env);
 }
 
-jni::Class<JsonArray> JsonArray::javaClass;
-
 } // namespace gson
 } // namespace android
 } // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/gson/json_array.hpp b/platform/android/src/gson/json_array.hpp
index c9ae98692f..24d5d3d291 100644
--- a/platform/android/src/gson/json_array.hpp
+++ b/platform/android/src/gson/json_array.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
-#include <mapbox/geometry.hpp>
-#include <mbgl/util/noncopyable.hpp>
+#include "json_element.hpp"
 
 #include <jni/jni.hpp>
 
@@ -9,15 +8,13 @@ namespace mbgl {
 namespace android {
 namespace gson {
 
-class JsonArray : private mbgl::util::noncopyable {
+class JsonArray {
 public:
+    using SuperTag = JsonElement;
     static constexpr auto Name() { return "com/google/gson/JsonArray"; };
 
-    static jni::Object<JsonArray> New(jni::JNIEnv&, const std::vector<mapbox::geometry::value>&);
-
-    static std::vector<mapbox::geometry::value> convert(JNIEnv&, jni::Object<JsonArray>);
-
-    static jni::Class<JsonArray> javaClass;
+    static jni::Local<jni::Object<JsonArray>> New(jni::JNIEnv&, const std::vector<mbgl::Value>&);
+    static std::vector<mbgl::Value> convert(JNIEnv&, const jni::Object<JsonArray>&);
 
     static void registerNative(jni::JNIEnv&);
 };
diff --git a/platform/android/src/gson/json_element.cpp b/platform/android/src/gson/json_element.cpp
index 5eaaf531f4..7c9a34c03c 100644
--- a/platform/android/src/gson/json_element.cpp
+++ b/platform/android/src/gson/json_element.cpp
@@ -1,90 +1,88 @@
 #include "json_element.hpp"
-
 #include "json_array.hpp"
 #include "json_object.hpp"
 #include "json_primitive.hpp"
 
-#include <mapbox/geometry/feature.hpp>
-#include <mapbox/variant.hpp>
-
 namespace mbgl {
 namespace android {
 namespace gson {
 
-/**
- * Turn mapbox::geometry::value into Java Gson JsonElement
- */
-class JsonElementEvaluator {
-public:
-
-    jni::JNIEnv& env;
-
-    jni::Object<JsonElement> operator()(const JsonPrimitive::value value) const {
-        return jni::Cast(env, JsonPrimitive::New(env, value), JsonElement::javaClass);
-    }
-
-    jni::Object<JsonElement> operator()(const std::vector<mapbox::geometry::value> &values) const {
-        return jni::Cast(env, JsonArray::New(env, values), JsonElement::javaClass);
-    }
-
-    jni::Object<JsonElement> operator()(const std::unordered_map<std::string, mapbox::geometry::value> &values) const {
-        return jni::Cast(env, JsonObject::New(env, values), JsonElement::javaClass);
-    }
-
-};
-
-
-jni::Object<JsonElement> JsonElement::New(jni::JNIEnv& env, const mapbox::geometry::value& value) {
-  JsonElementEvaluator evaluator { env } ;
-  return mapbox::geometry::value::visit(value, evaluator);
+jni::Local<jni::Object<JsonElement>> JsonElement::New(jni::JNIEnv& env, const mbgl::Value& value) {
+    static auto& primitive = jni::Class<JsonPrimitive>::Singleton(env);
+    static auto stringConstructor = primitive.GetConstructor<jni::String>(env);
+    static auto numberConstructor = primitive.GetConstructor<jni::Number>(env);
+    static auto booleanConstructor = primitive.GetConstructor<jni::Boolean>(env);
+
+    return value.match(
+        [&] (const mbgl::NullValue&) {
+            return jni::Local<jni::Object<JsonElement>>();
+        },
+        [&] (const std::string& value) {
+            return primitive.New(env, stringConstructor, jni::Make<jni::String>(env, value));
+        },
+        [&] (const double value) {
+            return primitive.New(env, numberConstructor, jni::Box(env, value));
+        },
+        [&] (const int64_t value) {
+            return primitive.New(env, numberConstructor, jni::Box(env, value));
+        },
+        [&] (const uint64_t value) {
+            return primitive.New(env, numberConstructor, jni::Box(env, int64_t(value))); // TODO: should use BigInteger
+        },
+        [&] (const bool value) {
+            return primitive.New(env, booleanConstructor, jni::Box(env, value ? jni::jni_true : jni::jni_false));
+        },
+        [&] (const std::vector<mbgl::Value>& values) {
+            return JsonArray::New(env, values);
+        },
+        [&] (const mbgl::PropertyMap& values) {
+            return JsonObject::New(env, values);
+        }
+    );
 }
 
-mapbox::geometry::value JsonElement::convert(jni::JNIEnv &env, jni::Object<JsonElement> jsonElement) {
-    mapbox::geometry::value value;
+mbgl::Value JsonElement::convert(jni::JNIEnv &env, const jni::Object<JsonElement>& jsonElement) {
+    if (!jsonElement) {
+        return mbgl::NullValue();
+    }
 
-    if (jsonElement) {
-        if (isJsonPrimitive(env, jsonElement)) {
-            auto primitive = JsonPrimitive::convert(env, jni::Cast(env, jsonElement, JsonPrimitive::javaClass));
-            value = mapbox::util::apply_visitor([](auto t) { return mapbox::geometry::value { t }; }, primitive);
-        } else if (isJsonObject(env, jsonElement)) {
-            mapbox::geometry::property_map map = JsonObject::convert(env, jni::Cast(env, jsonElement, JsonObject::javaClass));
-            value = mapbox::util::recursive_wrapper<std::unordered_map<std::string, mapbox::geometry::value>> { map } ;
-        } else  if (isJsonArray(env, jsonElement)) {
-            value = JsonArray::convert(env, jni::Cast(env, jsonElement, JsonArray::javaClass));
+    static auto& elementClass = jni::Class<JsonElement>::Singleton(env);
+    static auto isJsonObject = elementClass.GetMethod<jni::jboolean ()>(env, "isJsonObject");
+    static auto isJsonArray = elementClass.GetMethod<jni::jboolean ()>(env, "isJsonArray");
+    static auto isJsonPrimitive = elementClass.GetMethod<jni::jboolean ()>(env, "isJsonPrimitive");
+
+    static auto& primitiveClass = jni::Class<JsonPrimitive>::Singleton(env);
+    static auto isBoolean = primitiveClass.GetMethod<jni::jboolean ()>(env, "isBoolean");
+    static auto isString = primitiveClass.GetMethod<jni::jboolean ()>(env, "isString");
+    static auto isNumber = primitiveClass.GetMethod<jni::jboolean ()>(env, "isNumber");
+    static auto getAsBoolean = primitiveClass.GetMethod<jni::jboolean ()>(env, "getAsBoolean");
+    static auto getAsString = primitiveClass.GetMethod<jni::String ()>(env, "getAsString");
+    static auto getAsDouble = primitiveClass.GetMethod<jni::jdouble ()>(env, "getAsDouble");
+
+    if (jsonElement.Call(env, isJsonPrimitive)) {
+        auto primitive = jni::Cast(env, primitiveClass, jsonElement);
+        if (primitive.Call(env, isBoolean)) {
+            return bool(primitive.Call(env, getAsBoolean));
+        } else if (primitive.Call(env, isNumber)) {
+            return primitive.Call(env, getAsDouble); // TODO: how to differentiate types here?
+        } else if (primitive.Call(env, isString)) {
+            return jni::Make<std::string>(env, primitive.Call(env, getAsString));
         } else {
-            value = mapbox::geometry::null_value;
+            return mbgl::NullValue();
         }
+    } else if (jsonElement.Call(env, isJsonObject)) {
+        return JsonObject::convert(env, jni::Cast(env, jni::Class<JsonObject>::Singleton(env), jsonElement));
+    } else if (jsonElement.Call(env, isJsonArray)) {
+        return JsonArray::convert(env, jni::Cast(env, jni::Class<JsonArray>::Singleton(env), jsonElement));
+    } else {
+        return mbgl::NullValue();
     }
-    return value;
-}
-
-bool JsonElement::isJsonObject(JNIEnv& env, jni::Object<JsonElement> jsonElement) {
-    static auto method = JsonElement::javaClass.GetMethod<jni::jboolean ()>(env, "isJsonObject");
-    return jsonElement.Call(env, method);
-}
-
-bool JsonElement::isJsonArray(JNIEnv& env, jni::Object<JsonElement> jsonElement) {
-    static auto method = JsonElement::javaClass.GetMethod<jni::jboolean ()>(env, "isJsonArray");
-    return jsonElement.Call(env, method);
-}
-
-bool JsonElement::isJsonPrimitive(JNIEnv& env, jni::Object<JsonElement> jsonElement) {
-    static auto method = JsonElement::javaClass.GetMethod<jni::jboolean ()>(env, "isJsonPrimitive");
-    return jsonElement.Call(env, method);
-}
-
-bool JsonElement::isJsonNull(JNIEnv& env, jni::Object<JsonElement> jsonElement) {
-    static auto method = JsonElement::javaClass.GetMethod<jni::jboolean ()>(env, "isJsonNull");
-    return jsonElement.Call(env, method);
 }
 
 void JsonElement::registerNative(jni::JNIEnv &env) {
-    // Lookup the class
-    javaClass = *jni::Class<JsonElement>::Find(env).NewGlobalRef(env).release();
+    jni::Class<JsonElement>::Singleton(env);
 }
 
-jni::Class<JsonElement> JsonElement::javaClass;
-
 } // namespace gson
 } // namespace android
 } // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/gson/json_element.hpp b/platform/android/src/gson/json_element.hpp
index d850caa526..e3b8a0268d 100644
--- a/platform/android/src/gson/json_element.hpp
+++ b/platform/android/src/gson/json_element.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
-#include <mapbox/geometry.hpp>
-#include <mbgl/util/noncopyable.hpp>
+#include <mbgl/util/feature.hpp>
 
 #include <jni/jni.hpp>
 
@@ -9,23 +8,13 @@ namespace mbgl {
 namespace android {
 namespace gson {
 
-class JsonElement : private mbgl::util::noncopyable {
+class JsonElement {
 public:
+    using SuperTag = jni::ObjectTag;
     static constexpr auto Name() { return "com/google/gson/JsonElement"; };
 
-    static jni::Object<JsonElement> New(jni::JNIEnv&, const mapbox::geometry::value&);
-
-    static mapbox::geometry::value convert(JNIEnv&, jni::Object<JsonElement>);
-
-    static bool isJsonObject(JNIEnv&, jni::Object<JsonElement>);
-
-    static bool isJsonArray(JNIEnv&, jni::Object<JsonElement>);
-
-    static bool isJsonPrimitive(JNIEnv&, jni::Object<JsonElement>);
-
-    static bool isJsonNull(JNIEnv&, jni::Object<JsonElement>);
-
-    static jni::Class<JsonElement> javaClass;
+    static jni::Local<jni::Object<JsonElement>> New(jni::JNIEnv&, const mbgl::Value&);
+    static mbgl::Value convert(JNIEnv&, const jni::Object<JsonElement>&);
 
     static void registerNative(jni::JNIEnv&);
 };
diff --git a/platform/android/src/gson/json_object.cpp b/platform/android/src/gson/json_object.cpp
index 61b55f8b9e..10d244ee48 100644
--- a/platform/android/src/gson/json_object.cpp
+++ b/platform/android/src/gson/json_object.cpp
@@ -9,59 +9,46 @@ namespace android {
 namespace gson {
 
 
-jni::Object<JsonObject> JsonObject::New(jni::JNIEnv& env, const std::unordered_map<std::string, mapbox::geometry::value>& values) {
-    static auto constructor = JsonObject::javaClass.GetConstructor(env);
-    static auto addMethod = JsonObject::javaClass.GetMethod<void (jni::String, jni::Object<JsonElement>)>(env, "add");
+jni::Local<jni::Object<JsonObject>> JsonObject::New(jni::JNIEnv& env, const mbgl::PropertyMap& values) {
+    static auto& javaClass = jni::Class<JsonObject>::Singleton(env);
+    static auto constructor = javaClass.GetConstructor(env);
+    static auto addMethod = javaClass.GetMethod<void (jni::String, jni::Object<JsonElement>)>(env, "add");
 
-    jni::Object<JsonObject> jsonObject = JsonObject::javaClass.New(env, constructor);
+    auto jsonObject = javaClass.New(env, constructor);
 
     for (auto &item : values) {
-        jni::Object<JsonElement> jsonElement = JsonElement::New(env, item.second);
-        jni::String key = jni::Make<jni::String>(env, item.first);
-        jsonObject.Call(env, addMethod, key, jsonElement);
-        jni::DeleteLocalRef(env, jsonElement);
-        jni::DeleteLocalRef(env, key);
+        jsonObject.Call(env, addMethod,
+            jni::Make<jni::String>(env, item.first),
+            JsonElement::New(env, item.second));
     }
 
     return jsonObject;
 }
 
 template <typename F> // void (jni::String, jni::Object<gson::JsonElement>)
-static void iterateEntrySet(jni::JNIEnv& env, jni::Object<JsonObject> jsonObject, F callback) {
+static void iterateEntrySet(jni::JNIEnv& env, const jni::Object<JsonObject>& jsonObject, F callback) {
     // Get Set<Map.Entry<String, JsonElement>>
-    static auto method = JsonObject::javaClass.GetMethod<jni::Object<java::util::Set> ()>(env, "entrySet");
-    auto entrySet = jsonObject.Call(env, method);
-    jni::Array<jni::Object<java::util::Map::Entry>> entryArray = java::util::Set::toArray<java::util::Map::Entry>(env, entrySet);
+    static auto& javaClass = jni::Class<JsonObject>::Singleton(env);
+    static auto method = javaClass.GetMethod<jni::Object<java::util::Set> ()>(env, "entrySet");
+
+    auto entryArray = java::util::Set::toArray<java::util::Map::Entry>(env, jsonObject.Call(env, method));
 
     size_t size = entryArray.Length(env);
     for (size_t i = 0; i < size; i++) {
         auto entry = entryArray.Get(env, i);
         if (entry) {
-            // Convert
-            auto jKey = java::util::Map::Entry::getKey<jni::ObjectTag>(env, entry);
-            auto jKeyString = jni::String(reinterpret_cast<jni::jstring*>(jKey.Get()));
-            auto jValue = java::util::Map::Entry::getValue<gson::JsonElement>(env, entry);
-
-            // Callback
-            callback(jKeyString, jValue);
-
-            // Cleanup
-            // Skip jKey as it points to the same as jKeyString
-            jni::DeleteLocalRef(env, jKeyString);
-            jni::DeleteLocalRef(env, jValue);
+            callback(
+                java::util::Map::Entry::getKey<jni::StringTag>(env, entry),
+                java::util::Map::Entry::getValue<gson::JsonElement>(env, entry));
         }
-        jni::DeleteLocalRef(env, entry);
     }
-
-    jni::DeleteLocalRef(env, entrySet);
-    jni::DeleteLocalRef(env, entryArray);
 }
 
-mapbox::geometry::property_map JsonObject::convert(jni::JNIEnv &env, jni::Object<JsonObject> jsonObject) {
-    mapbox::geometry::property_map map;
+mbgl::PropertyMap JsonObject::convert(jni::JNIEnv& env, const jni::Object<JsonObject>& jsonObject) {
+    mbgl::PropertyMap map;
 
     if (jsonObject) {
-        iterateEntrySet(env, jsonObject, [&map, &env](jni::String jId, jni::Object<gson::JsonElement> jsonElement) {
+        iterateEntrySet(env, jsonObject, [&map, &env](const jni::String& jId, const jni::Object<gson::JsonElement>& jsonElement) {
             map[jni::Make<std::string>(env, jId)] = JsonElement::convert(env, jsonElement);
         });
     }
@@ -70,12 +57,9 @@ mapbox::geometry::property_map JsonObject::convert(jni::JNIEnv &env, jni::Object
 }
 
 void JsonObject::registerNative(jni::JNIEnv &env) {
-    // Lookup the class
-    javaClass = *jni::Class<JsonObject>::Find(env).NewGlobalRef(env).release();
+    jni::Class<JsonObject>::Singleton(env);
 }
 
-jni::Class<JsonObject> JsonObject::javaClass;
-
 } // namespace gson
 } // namespace android
 } // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/gson/json_object.hpp b/platform/android/src/gson/json_object.hpp
index 4bc61e51a2..b8916f8ae1 100644
--- a/platform/android/src/gson/json_object.hpp
+++ b/platform/android/src/gson/json_object.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
-#include <mapbox/geometry.hpp>
-#include <mbgl/util/noncopyable.hpp>
+#include "json_element.hpp"
 
 #include <jni/jni.hpp>
 
@@ -9,15 +8,13 @@ namespace mbgl {
 namespace android {
 namespace gson {
 
-class JsonObject : private mbgl::util::noncopyable {
+class JsonObject {
 public:
+    using SuperTag = JsonElement;
     static constexpr auto Name() { return "com/google/gson/JsonObject"; };
 
-    static jni::Object<JsonObject> New(jni::JNIEnv&, const std::unordered_map<std::string, mapbox::geometry::value>&);
-
-    static mapbox::geometry::property_map convert(JNIEnv&, jni::Object<JsonObject>);
-
-    static jni::Class<JsonObject> javaClass;
+    static jni::Local<jni::Object<JsonObject>> New(jni::JNIEnv&, const mbgl::PropertyMap&);
+    static mbgl::PropertyMap convert(JNIEnv&, const jni::Object<JsonObject>&);
 
     static void registerNative(jni::JNIEnv&);
 };
diff --git a/platform/android/src/gson/json_primitive.cpp b/platform/android/src/gson/json_primitive.cpp
index 4e171c4845..79d6b07617 100644
--- a/platform/android/src/gson/json_primitive.cpp
+++ b/platform/android/src/gson/json_primitive.cpp
@@ -1,146 +1,13 @@
 #include "json_primitive.hpp"
-#include "../java/lang.hpp"
 
 namespace mbgl {
 namespace android {
 namespace gson {
 
-/**
- * Turn mapbox::geometry::value into Java Gson JsonPrimitives
- */
-class JsonPrimitiveEvaluator {
-public:
-
-    jni::JNIEnv& env;
-
-    /**
-     * Create a null primitive
-     */
-    jni::Object<JsonPrimitive> operator()(const mapbox::geometry::null_value_t) const {
-        return jni::Object<JsonPrimitive>();
-    }
-
-    /**
-     * Create a primitive containing a string value
-     */
-    jni::Object<JsonPrimitive> operator()(const std::string value) const {
-        static auto constructor = JsonPrimitive::javaClass.GetConstructor<jni::String>(env);
-        auto jvalue = jni::Make<jni::String>(env, value);
-        auto jsonPrimitive = JsonPrimitive::javaClass.New(env, constructor, jvalue);
-        jni::DeleteLocalRef(env, jvalue);
-        return jsonPrimitive;
-    }
-
-    /**
-     * Create a primitive containing a number value with type double
-     */
-    jni::Object<JsonPrimitive> operator()(const double value) const {
-        static auto constructor = JsonPrimitive::javaClass.GetConstructor<jni::Object<java::lang::Number>>(env);
-        auto boxedValue = java::lang::Double::valueOf(env, value);
-        auto number = jni::Cast(env, boxedValue, java::lang::Number::javaClass);
-        auto jsonPrimitive = JsonPrimitive::javaClass.New(env, constructor, number);
-        jni::DeleteLocalRef(env, boxedValue);
-        return jsonPrimitive;
-    }
-
-    /**
-     * Create a primitive containing a number value with type long
-     */
-    jni::Object<JsonPrimitive> operator()(const int64_t value) const {
-        static auto constructor = JsonPrimitive::javaClass.GetConstructor<jni::Object<java::lang::Number>>(env);
-        auto boxedValue = java::lang::Long::valueOf(env, value);
-        auto number = jni::Cast(env, boxedValue, java::lang::Number::javaClass);
-        auto jsonPrimitive =  JsonPrimitive::javaClass.New(env, constructor, number);
-        jni::DeleteLocalRef(env, boxedValue);
-        return jsonPrimitive;
-    }
-
-    /**
-     * Create a primitive containing a number value with type long
-     */
-    jni::Object<JsonPrimitive> operator()(const uint64_t value) const {
-        static auto constructor = JsonPrimitive::javaClass.GetConstructor<jni::Object<java::lang::Number>>(env);
-        auto boxedValue = java::lang::Long::valueOf(env, value);
-        auto number = jni::Cast(env, boxedValue, java::lang::Number::javaClass);
-        auto jsonPrimitive = JsonPrimitive::javaClass.New(env, constructor, number);
-        jni::DeleteLocalRef(env, boxedValue);
-        return jsonPrimitive;
-    }
-
-    /**
-     * Create a primitive containing a boolean value
-     */
-    jni::Object<JsonPrimitive> operator()(const bool value) const {
-        static auto constructor = JsonPrimitive::javaClass.GetConstructor<jni::Object<java::lang::Boolean>>(env);
-        auto boxedValue = java::lang::Boolean::valueOf(env, value);
-        auto jsonPrimitive = JsonPrimitive::javaClass.New(env, constructor, boxedValue);
-        jni::DeleteLocalRef(env, boxedValue);
-        return jsonPrimitive;
-    }
-};
-
-jni::Object<JsonPrimitive> JsonPrimitive::New(jni::JNIEnv &env, const value& value) {
-    JsonPrimitiveEvaluator evaluator { env };
-    return value::visit(value, evaluator);
-}
-
-JsonPrimitive::value JsonPrimitive::convert(jni::JNIEnv &env, jni::Object<JsonPrimitive> jsonPrimitive) {
-    value value;
-    if (jsonPrimitive) {
-        if (isBoolean(env, jsonPrimitive)) {
-            value = getAsBoolean(env, jsonPrimitive);
-        } else if (isNumber(env, jsonPrimitive)) {
-            //TODO: how to differentiate types here?
-            value = getAsDouble(env, jsonPrimitive);
-        } else if (isString(env, jsonPrimitive)) {
-            value = getAsString(env, jsonPrimitive);
-        } else {
-            value = mapbox::geometry::null_value;
-        }
-    }
-    return value;
-}
-
-bool JsonPrimitive::isBoolean(JNIEnv& env, jni::Object<JsonPrimitive> jsonPrimitive) {
-    static auto method = JsonPrimitive::javaClass.GetMethod<jni::jboolean ()>(env, "isBoolean");
-    return jsonPrimitive.Call(env, method);
-}
-
-bool JsonPrimitive::isString(JNIEnv& env, jni::Object<JsonPrimitive> jsonPrimitive) {
-    static auto method = JsonPrimitive::javaClass.GetMethod<jni::jboolean ()>(env, "isString");
-    return jsonPrimitive.Call(env, method);
-}
-
-bool JsonPrimitive::isNumber(JNIEnv& env, jni::Object<JsonPrimitive> jsonPrimitive) {
-    static auto method = JsonPrimitive::javaClass.GetMethod<jni::jboolean ()>(env, "isNumber");
-    return jsonPrimitive.Call(env, method);
-}
-
-bool JsonPrimitive::getAsBoolean(JNIEnv& env, jni::Object<JsonPrimitive> jsonPrimitive) {
-    static auto method = JsonPrimitive::javaClass.GetMethod<jni::jboolean ()>(env, "getAsBoolean");
-    return jsonPrimitive.Call(env, method);
-}
-
-std::string JsonPrimitive::getAsString(JNIEnv& env, jni::Object<JsonPrimitive> jsonPrimitive) {
-    static auto method = JsonPrimitive::javaClass.GetMethod<jni::String ()>(env, "getAsString");
-    auto jString = jsonPrimitive.Call(env, method);
-    auto string = jni::Make<std::string>(env, jString);
-    jni::DeleteLocalRef(env, jString);
-    return string;
-}
-
-double JsonPrimitive::getAsDouble(JNIEnv& env, jni::Object<JsonPrimitive> jsonPrimitive) {
-    static auto method = JsonPrimitive::javaClass.GetMethod<jni::jdouble ()>(env, "getAsDouble");
-    return jsonPrimitive.Call(env, method);
-}
-
 void JsonPrimitive::registerNative(jni::JNIEnv &env) {
-    // Lookup the class
-    javaClass = *jni::Class<JsonPrimitive>::Find(env).NewGlobalRef(env).release();
+    jni::Class<JsonPrimitive>::Singleton(env);
 }
 
-jni::Class<JsonPrimitive> JsonPrimitive::javaClass;
-
 } // namespace gson
 } // namespace android
 } // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/gson/json_primitive.hpp b/platform/android/src/gson/json_primitive.hpp
index c418e0ebe8..36f138d902 100644
--- a/platform/android/src/gson/json_primitive.hpp
+++ b/platform/android/src/gson/json_primitive.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
-#include <mapbox/geometry.hpp>
-#include <mbgl/util/noncopyable.hpp>
+#include "json_element.hpp"
 
 #include <jni/jni.hpp>
 
@@ -9,30 +8,11 @@ namespace mbgl {
 namespace android {
 namespace gson {
 
-class JsonPrimitive : private mbgl::util::noncopyable {
+class JsonPrimitive {
 public:
-    using value = mapbox::util::variant<mapbox::geometry::null_value_t, bool, uint64_t, int64_t, double, std::string>;
-
+    using SuperTag = JsonElement;
     static constexpr auto Name() { return "com/google/gson/JsonPrimitive"; };
 
-    static jni::Object<JsonPrimitive> New(jni::JNIEnv&, const value&);
-
-    static value convert(JNIEnv&, jni::Object<JsonPrimitive>);
-
-    static bool isBoolean(JNIEnv&, jni::Object<JsonPrimitive>);
-
-    static bool isString(JNIEnv&, jni::Object<JsonPrimitive>);
-
-    static bool isNumber(JNIEnv&, jni::Object<JsonPrimitive>);
-
-    static bool getAsBoolean(JNIEnv&, jni::Object<JsonPrimitive>);
-
-    static std::string getAsString(JNIEnv&, jni::Object<JsonPrimitive>);
-
-    static double getAsDouble(JNIEnv&, jni::Object<JsonPrimitive>);
-
-    static jni::Class<JsonPrimitive> javaClass;
-
     static void registerNative(jni::JNIEnv&);
 };