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

# Conflicts:
#	cmake/mason-dependencies.cmake

23 files changed, 217 insertions, 588 deletions

diff --git a/platform/android/src/geojson/conversion/feature.cpp b/platform/android/src/geojson/conversion/feature.cpp
deleted file mode 100644
index 3cb6d37b17..0000000000
--- a/platform/android/src/geojson/conversion/feature.cpp
+++ /dev/null
@@ -1,191 +0,0 @@
-#include "feature.hpp"
-
-#include "../../conversion/constant.hpp"
-#include "../../conversion/conversion.hpp"
-#include "../../jni/local_object.hpp"
-
-namespace mbgl {
-namespace android {
-namespace conversion {
-
-/**
- * Turn feature identifier into std::string
- */
-class FeatureIdVisitor {
-public:
-
-    template<class T>
-    std::string operator()(const T& i) const {
-        return std::to_string(i);
-    }
-
-    std::string operator()(const std::string& i) const {
-        return i;
-    }
-
-    std::string operator()(const std::nullptr_t&) const {
-        return "";
-    }
-
-};
-
-/**
- * Turn properties into Java GSON JsonObject's
- */
-class PropertyValueEvaluator {
-public:
-    jni::JNIEnv& env;
-
-    /**
-     * null
-     */
-    jni::jobject* operator()(const mapbox::geometry::null_value_t &) const {
-        return (jni::jobject*) nullptr;
-    }
-
-    /**
-     * Boolean primitive
-     */
-    jni::jobject* operator()(const bool& value) const {
-        static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/google/gson/JsonPrimitive")).release();
-        static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "(Ljava/lang/Boolean;)V");
-
-        // Create JsonPrimitive
-        jni::LocalObject<jni::jobject> converted = jni::NewLocalObject(env, *convert<jni::jobject*, bool>(env, value));
-        jni::jobject* object = &jni::NewObject(env, *javaClass, *constructor, *converted);
-
-        return object;
-    }
-
-    /**
-     * String primitive
-     */
-    jni::jobject* operator()(const std::string& value) const {
-        static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/google/gson/JsonPrimitive")).release();
-        static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "(Ljava/lang/String;)V");
-
-        // Create JsonPrimitive
-        jni::LocalObject<jni::jobject> converted = jni::NewLocalObject(env, *convert<jni::jobject*, std::string>(env, value));
-        jni::jobject* object = &jni::NewObject(env, *javaClass, *constructor, converted.get());
-
-        return object;
-    }
-
-    /**
-     * Number primitives
-     */
-    template <class Number>
-    jni::jobject* operator()(const Number& value) const {
-        static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/google/gson/JsonPrimitive")).release();
-        static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "(Ljava/lang/Number;)V");
-
-        // Create JsonPrimitive
-        jni::LocalObject<jni::jobject> converted = jni::NewLocalObject(env, *convert<jni::jobject*, Number>(env, value));
-        jni::jobject* object = &jni::NewObject(env, *javaClass, *constructor, converted.get());
-
-        return object;
-    }
-
-
-    /**
-     * Json Array
-     */
-    jni::jobject* operator()(const std::vector<mbgl::Value> &values) const {
-        static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/google/gson/JsonArray")).release();
-        static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "()V");;
-        static jni::jmethodID* add = &jni::GetMethodID(env, *javaClass, "add", "(Lcom/google/gson/JsonElement;)V");
-
-        // Create json array
-        jni::jobject* jarray = &jni::NewObject(env, *javaClass, *constructor);
-
-        // Add values
-        for (const auto &v : values) {
-            jni::LocalObject<jni::jobject> converted = jni::NewLocalObject(env, mbgl::Value::visit(v, *this));
-            jni::CallMethod<void>(env, jarray, *add, converted.get());
-        }
-
-        return jarray;
-    }
-
-    /**
-     * Json Object
-     */
-    jni::jobject* operator()(const std::unordered_map<std::string, mbgl::Value> &value) const {
-        // TODO: clean up duplication here
-        static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/google/gson/JsonObject")).release();
-        static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "()V");;
-        static jni::jmethodID* add = &jni::GetMethodID(env, *javaClass, "add", "(Ljava/lang/String;Lcom/google/gson/JsonElement;)V");
-
-        // Create json object
-        jni::jobject* jsonObject = &jni::NewObject(env, *javaClass, *constructor);
-
-        // Add items
-        for (auto &item : value) {
-            jni::LocalObject<jni::jobject> converted = jni::NewLocalObject(env, mbgl::Value::visit(item.second, *this));
-            jni::LocalObject<jni::jobject> key = jni::NewLocalObject(env, *convert<jni::jobject*, std::string>(env, item.first));
-            jni::CallMethod<void>(env, jsonObject, *add, key.get(), converted.get());
-        }
-
-        return jsonObject;
-    }
-};
-
-Result<jni::jobject*> Converter<jni::jobject*, std::unordered_map<std::string, mbgl::Value>>::operator()(jni::JNIEnv& env, const std::unordered_map<std::string, mbgl::Value>& value) const {
-    static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/google/gson/JsonObject")).release();
-    static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "()V");;
-    static jni::jmethodID* add = &jni::GetMethodID(env, *javaClass, "add", "(Ljava/lang/String;Lcom/google/gson/JsonElement;)V");
-
-    // Create json object
-    jni::jobject* jsonObject = &jni::NewObject(env, *javaClass, *constructor);
-
-    // Add items
-    PropertyValueEvaluator evaluator {env};
-    for (auto &item : value) {
-        jni::LocalObject<jni::jobject> converted = jni::NewLocalObject(env, mbgl::Value::visit(item.second, evaluator));
-        jni::LocalObject<jni::jobject> key = jni::NewLocalObject(env, *convert<jni::jobject*, std::string>(env, item.first));
-        jni::CallMethod<void>(env, jsonObject, *add, key.get(), converted.get());
-    }
-
-    return {jsonObject};
-}
-
-Result<jni::Object<android::geojson::Feature>> Converter<jni::Object<android::geojson::Feature>, mbgl::Feature>::operator()(jni::JNIEnv& env, const mbgl::Feature& value) const {
-
-    // Convert Id
-    FeatureIdVisitor idEvaluator;
-    std::string id = (value.id) ? mapbox::geometry::identifier::visit(value.id.value(), idEvaluator) : "";
-    auto jid = jni::Make<jni::String>(env, id);
-
-    // Convert properties
-    auto properties = jni::Object<gson::JsonObject>(*convert<jni::jobject*>(env, value.properties));
-
-    // Convert geometry
-    auto geometry = android::geojson::Geometry::New(env, value.geometry);
-
-    // Create feature
-    auto feature = android::geojson::Feature::fromGeometry(env, geometry, properties, jid);
-
-    //Cleanup
-    jni::DeleteLocalRef(env, jid);
-    jni::DeleteLocalRef(env, geometry);
-    jni::DeleteLocalRef(env, properties);
-
-    return feature;
-}
-
-Result<jni::Array<jni::Object<android::geojson::Feature>>> Converter<jni::Array<jni::Object<android::geojson::Feature>>, std::vector<mbgl::Feature>>::operator()(jni::JNIEnv& env, const std::vector<mbgl::Feature>& value) const {
-    using namespace mbgl::android::geojson;
-    auto features = jni::Array<jni::Object<Feature>>::New(env, value.size(), Feature::javaClass);
-
-    for(size_t i = 0; i < value.size(); i = i + 1) {
-        auto converted = *convert<jni::Object<android::geojson::Feature>, mbgl::Feature>(env, value.at(i));
-        features.Set(env, i, converted);
-        jni::DeleteLocalRef(env, converted);
-    }
-
-    return {features};
-}
-
-} // namespace conversion
-} // namespace android
-} // namespace mbgl
diff --git a/platform/android/src/geojson/conversion/feature.hpp b/platform/android/src/geojson/conversion/feature.hpp
deleted file mode 100644
index 031449cd23..0000000000
--- a/platform/android/src/geojson/conversion/feature.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#pragma once
-
-#include "../../conversion/conversion.hpp"
-#include "../feature.hpp"
-
-#include <mbgl/util/feature.hpp>
-#include <jni/jni.hpp>
-
-#include <vector>
-#include <unordered_map>
-
-namespace mbgl {
-namespace android {
-namespace conversion {
-
-template <>
-struct Converter<jni::jobject*, std::unordered_map<std::string, mbgl::Value>> {
-    Result<jni::jobject*> operator()(jni::JNIEnv& env, const std::unordered_map<std::string, mbgl::Value>& value) const;
-};
-
-template <>
-struct Converter<jni::Object<android::geojson::Feature>, mbgl::Feature> {
-    Result<jni::Object<android::geojson::Feature>> operator()(jni::JNIEnv& env, const mbgl::Feature& value) const;
-};
-
-template <>
-struct Converter<jni::Array<jni::Object<android::geojson::Feature>>, std::vector<mbgl::Feature>> {
-    Result<jni::Array<jni::Object<android::geojson::Feature>>> operator()(jni::JNIEnv& env, const std::vector<mbgl::Feature>& value) const;
-};
-
-} // namespace conversion
-} // namespace android
-} // namespace mbgl
diff --git a/platform/android/src/geojson/feature.cpp b/platform/android/src/geojson/feature.cpp
index d8a4e829e2..f0ed097842 100644
--- a/platform/android/src/geojson/feature.cpp
+++ b/platform/android/src/geojson/feature.cpp
@@ -1,63 +1,74 @@
 #include "feature.hpp"
-
 #include "geometry.hpp"
+#include "../gson/json_object.hpp"
+
+#include <mbgl/util/string.hpp>
 
 namespace mbgl {
 namespace android {
 namespace geojson {
 
-mbgl::Feature Feature::convert(jni::JNIEnv& env, jni::Object<Feature> jFeature) {
-    // Convert
-    auto jGeometry = geometry(env, jFeature);
-    auto jProperties = Feature::properties(env, jFeature);
+using namespace gson;
 
-    std::experimental::optional<mapbox::geometry::identifier> id;
-    auto jId = Feature::id(env, jFeature);
-    if (jId) {
-        id = {  jni::Make<std::string>(env, jId) };
-    }
+mbgl::Feature Feature::convert(jni::JNIEnv& env, const jni::Object<Feature>& jFeature) {
+    static auto& javaClass = jni::Class<Feature>::Singleton(env);
+    static auto id = javaClass.GetMethod<jni::String ()>(env, "id");
+    static auto geometry = javaClass.GetMethod<jni::Object<Geometry> ()>(env, "geometry");
+    static auto properties = javaClass.GetMethod<jni::Object<gson::JsonObject> ()>(env, "properties");
+
+    auto jId = jFeature.Call(env, id);
 
-    auto feature = mbgl::Feature {
-            Geometry::convert(env, jGeometry),
-            gson::JsonObject::convert(env, jProperties),
-            id
+    return mbgl::Feature {
+        Geometry::convert(env, jFeature.Call(env, geometry)),
+        JsonObject::convert(env, jFeature.Call(env, properties)),
+        jId ? std::experimental::optional<mapbox::geometry::identifier>(jni::Make<std::string>(env, jId))
+            : std::experimental::nullopt
     };
+}
 
-    // Cleanup
-    jni::DeleteLocalRef(env, jGeometry);
-    jni::DeleteLocalRef(env, jProperties);
-    jni::DeleteLocalRef(env, jId);
+/**
+ * Turn feature identifier into std::string
+ */
+class FeatureIdVisitor {
+public:
+    template<class T>
+    std::string operator()(const T& i) const {
+        return std::to_string(i);
+    }
 
-    return feature;
-}
+    std::string operator()(const std::string& i) const {
+        return i;
+    }
 
-jni::Object<Geometry> Feature::geometry(jni::JNIEnv& env, jni::Object<Feature> jFeature) {
-    static auto method = Feature::javaClass.GetMethod<jni::Object<Geometry> ()>(env, "geometry");
-    return jFeature.Call(env, method);
-}
+    std::string operator()(const std::nullptr_t&) const {
+        return "";
+    }
+};
 
-jni::Object<gson::JsonObject> Feature::properties(jni::JNIEnv& env, jni::Object<Feature> jFeature) {
-    static auto method = Feature::javaClass.GetMethod<jni::Object<gson::JsonObject> ()>(env, "properties");
-    return jFeature.Call(env, method);
-}
+jni::Local<jni::Object<Feature>> convertFeature(jni::JNIEnv& env, const mbgl::Feature& value) {
+    static auto& javaClass = jni::Class<Feature>::Singleton(env);
+    static auto method = javaClass.GetStaticMethod<jni::Object<Feature> (jni::Object<Geometry>, jni::Object<JsonObject>, jni::String)>(env, "fromGeometry");
 
-jni::String Feature::id(jni::JNIEnv& env, jni::Object<Feature> jFeature) {
-    static auto method = Feature::javaClass.GetMethod<jni::String ()>(env, "id");
-    return jFeature.Call(env, method);
+    return javaClass.Call(env, method,
+        Geometry::New(env, value.geometry),
+        JsonObject::New(env, value.properties),
+        jni::Make<jni::String>(env, value.id ? value.id.value().match(FeatureIdVisitor()) : ""));
 }
 
-jni::Object<Feature> Feature::fromGeometry(jni::JNIEnv& env, jni::Object<Geometry> geometry, jni::Object<gson::JsonObject> properties, jni::String id) {
-    static auto method = Feature::javaClass.GetStaticMethod<jni::Object<Feature> (jni::Object<Geometry>, jni::Object<gson::JsonObject>, jni::String)>(env, "fromGeometry");
-    return Feature::javaClass.Call(env, method, geometry, properties, id);
+jni::Local<jni::Array<jni::Object<Feature>>> Feature::convert(jni::JNIEnv& env, const std::vector<mbgl::Feature>& value) {
+    auto features = jni::Array<jni::Object<Feature>>::New(env, value.size());
+
+    for (size_t i = 0; i < value.size(); i = i + 1) {
+        features.Set(env, i, convertFeature(env, value.at(i)));
+    }
+
+    return features;
 }
 
 void Feature::registerNative(jni::JNIEnv& env) {
-    // Lookup the class
-    Feature::javaClass = *jni::Class<Feature>::Find(env).NewGlobalRef(env).release();
+    jni::Class<Feature>::Singleton(env);
 }
 
-jni::Class<Feature> Feature::javaClass;
-
 } // namespace geojson
 } // namespace android
 } // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/geojson/feature.hpp b/platform/android/src/geojson/feature.hpp
index ab59d783e5..fdf5d977ba 100644
--- a/platform/android/src/geojson/feature.hpp
+++ b/platform/android/src/geojson/feature.hpp
@@ -1,37 +1,21 @@
 #pragma once
 
 #include <mbgl/util/feature.hpp>
-#include <mbgl/util/geometry.hpp>
-#include <mbgl/util/noncopyable.hpp>
 
 #include <jni/jni.hpp>
 
-#include "geometry.hpp"
-#include "../gson/json_object.hpp"
-
 namespace mbgl {
 namespace android {
 namespace geojson {
 
-class Feature : private mbgl::util::noncopyable {
+class Feature {
 public:
-
     static constexpr auto Name() { return "com/mapbox/geojson/Feature"; };
 
-    static jni::Object<Feature> fromGeometry(jni::JNIEnv&, jni::Object<Geometry>, jni::Object<gson::JsonObject>, jni::String);
-
-    static mbgl::Feature convert(jni::JNIEnv&, jni::Object<Feature>);
-
-    static jni::Object<Geometry> geometry(jni::JNIEnv&, jni::Object<Feature>);
-
-    static jni::String id(jni::JNIEnv&, jni::Object<Feature>);
-
-    static jni::Object<gson::JsonObject> properties(jni::JNIEnv&, jni::Object<Feature>);
-
-    static jni::Class<Feature> javaClass;
+    static mbgl::Feature convert(jni::JNIEnv&, const jni::Object<Feature>&);
+    static jni::Local<jni::Array<jni::Object<Feature>>> convert(jni::JNIEnv&, const std::vector<mbgl::Feature>&);
 
     static void registerNative(jni::JNIEnv&);
-
 };
 
 } // namespace geojson
diff --git a/platform/android/src/geojson/feature_collection.cpp b/platform/android/src/geojson/feature_collection.cpp
index 18a41d48fa..f90d5226b7 100644
--- a/platform/android/src/geojson/feature_collection.cpp
+++ b/platform/android/src/geojson/feature_collection.cpp
@@ -6,7 +6,7 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-mbgl::FeatureCollection FeatureCollection::convert(jni::JNIEnv& env, jni::Object<FeatureCollection> jCollection) {
+mbgl::FeatureCollection FeatureCollection::convert(jni::JNIEnv& env, const jni::Object<FeatureCollection>& jCollection) {
     auto collection = mbgl::FeatureCollection();
 
     if (jCollection) {
@@ -16,29 +16,22 @@ mbgl::FeatureCollection FeatureCollection::convert(jni::JNIEnv& env, jni::Object
         collection.reserve(size);
 
         for (size_t i = 0; i < size; i++) {
-            auto jFeature = jFeatures.Get(env, i);
-            collection.push_back(Feature::convert(env, jFeature));
-            jni::DeleteLocalRef(env, jFeature);
+            collection.push_back(Feature::convert(env, jFeatures.Get(env, i)));
         }
-
-        jni::DeleteLocalRef(env, jFeatures);
-        jni::DeleteLocalRef(env, jFeatureList);
     }
     return collection;
 }
 
-jni::Object<java::util::List> FeatureCollection::features(jni::JNIEnv& env, jni::Object<FeatureCollection> jCollection) {
-    static auto method = FeatureCollection::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "features");
+jni::Local<jni::Object<java::util::List>> FeatureCollection::features(jni::JNIEnv& env, const jni::Object<FeatureCollection>& jCollection) {
+    static auto& javaClass = jni::Class<FeatureCollection>::Singleton(env);
+    static auto method = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "features");
     return jCollection.Call(env, method);
 }
 
 void FeatureCollection::registerNative(jni::JNIEnv& env) {
-    // Lookup the class
-    javaClass = *jni::Class<FeatureCollection>::Find(env).NewGlobalRef(env).release();
+    jni::Class<FeatureCollection>::Singleton(env);
 }
 
-jni::Class<FeatureCollection> FeatureCollection::javaClass;
-
 } // namespace geojson
 } // namespace android
 } // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/geojson/feature_collection.hpp b/platform/android/src/geojson/feature_collection.hpp
index 259ffab370..66e92eacad 100644
--- a/platform/android/src/geojson/feature_collection.hpp
+++ b/platform/android/src/geojson/feature_collection.hpp
@@ -3,7 +3,6 @@
 #include "../java/util.hpp"
 
 #include <mbgl/util/geojson.hpp>
-#include <mbgl/util/noncopyable.hpp>
 
 #include <jni/jni.hpp>
 
@@ -11,15 +10,13 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-class FeatureCollection : private mbgl::util::noncopyable {
+class FeatureCollection {
 public:
     static constexpr auto Name() { return "com/mapbox/geojson/FeatureCollection"; };
 
-    static mbgl::FeatureCollection convert(jni::JNIEnv&, jni::Object<FeatureCollection>);
+    static mbgl::FeatureCollection convert(jni::JNIEnv&, const jni::Object<FeatureCollection>&);
 
-    static jni::Object<java::util::List> features(jni::JNIEnv&, jni::Object<FeatureCollection>);
-
-    static jni::Class<FeatureCollection> javaClass;
+    static jni::Local<jni::Object<java::util::List>> features(jni::JNIEnv&, const jni::Object<FeatureCollection>&);
 
     static void registerNative(jni::JNIEnv&);
 };
diff --git a/platform/android/src/geojson/geometry.cpp b/platform/android/src/geojson/geometry.cpp
index 5635b5a0f5..2356af780a 100644
--- a/platform/android/src/geojson/geometry.cpp
+++ b/platform/android/src/geojson/geometry.cpp
@@ -22,76 +22,71 @@ public:
 
     jni::JNIEnv& env;
 
-    jni::Object<Geometry> operator()(const mbgl::Point<double> &geometry) const {
-        return jni::Cast(env, Point::New(env, geometry), Geometry::javaClass);
+    jni::Local<jni::Object<Geometry>> operator()(const mbgl::Point<double> &geometry) const {
+        return Point::New(env, geometry);
     }
 
-    jni::Object<Geometry> operator()(const mbgl::LineString<double> &geometry) const {
-        return jni::Cast(env, LineString::New(env, geometry), Geometry::javaClass);
+    jni::Local<jni::Object<Geometry>> operator()(const mbgl::LineString<double> &geometry) const {
+        return LineString::New(env, geometry);
     }
 
-    jni::Object<Geometry>  operator()(const mbgl::MultiLineString<double> &geometry) const {
-        return jni::Cast(env, MultiLineString::New(env, geometry), Geometry::javaClass);
+    jni::Local<jni::Object<Geometry>>  operator()(const mbgl::MultiLineString<double> &geometry) const {
+        return MultiLineString::New(env, geometry);
     }
 
-    jni::Object<Geometry> operator()(const mbgl::MultiPoint<double> &geometry) const {
-        return jni::Cast(env, MultiPoint::New(env, geometry), Geometry::javaClass);
+    jni::Local<jni::Object<Geometry>> operator()(const mbgl::MultiPoint<double> &geometry) const {
+        return MultiPoint::New(env, geometry);
     }
 
-    jni::Object<Geometry> operator()(const mbgl::Polygon<double> &geometry) const {
-        return jni::Cast(env, Polygon::New(env, geometry), Geometry::javaClass);
+    jni::Local<jni::Object<Geometry>> operator()(const mbgl::Polygon<double> &geometry) const {
+        return Polygon::New(env, geometry);
     }
 
-    jni::Object<Geometry>  operator()(const mbgl::MultiPolygon<double> &geometry) const {
-        return jni::Cast(env, MultiPolygon::New(env, geometry), Geometry::javaClass);
+    jni::Local<jni::Object<Geometry>>  operator()(const mbgl::MultiPolygon<double> &geometry) const {
+        return MultiPolygon::New(env, geometry);
     }
 
-    jni::Object<Geometry>  operator()(const mapbox::geometry::geometry_collection<double> &geometry) const {
-        return jni::Cast(env, GeometryCollection::New(env, geometry), Geometry::javaClass);
+    jni::Local<jni::Object<Geometry>>  operator()(const mapbox::geometry::geometry_collection<double> &geometry) const {
+        return GeometryCollection::New(env, geometry);
     }
 };
 
-jni::Object<Geometry> Geometry::New(jni::JNIEnv& env, mbgl::Geometry<double> geometry) {
+jni::Local<jni::Object<Geometry>> Geometry::New(jni::JNIEnv& env, mbgl::Geometry<double> geometry) {
     GeometryEvaluator evaluator { env } ;
     return mbgl::Geometry<double>::visit(geometry, evaluator);
 }
 
-mbgl::Geometry<double> Geometry::convert(jni::JNIEnv &env, jni::Object<Geometry> jGeometry) {
+mbgl::Geometry<double> Geometry::convert(jni::JNIEnv &env, const jni::Object<Geometry>& jGeometry) {
     auto type = Geometry::getType(env, jGeometry);
     if (type == Point::Type()) {
-        return { Point::convert(env, jni::Object<Point>(jGeometry.Get())) };
+        return { Point::convert(env, jni::Cast(env, jni::Class<Point>::Singleton(env), jGeometry)) };
     } else if (type == MultiPoint::Type()) {
-        return { MultiPoint::convert(env, jni::Object<MultiPoint>(jGeometry.Get())) };
+        return { MultiPoint::convert(env, jni::Cast(env, jni::Class<MultiPoint>::Singleton(env), jGeometry)) };
     } else if (type == LineString::Type()) {
-        return { LineString::convert(env, jni::Object<LineString>(jGeometry.Get())) };
+        return { LineString::convert(env, jni::Cast(env, jni::Class<LineString>::Singleton(env), jGeometry)) };
     } else if (type == MultiLineString::Type()) {
-        return { MultiLineString::convert(env, jni::Object<MultiLineString>(jGeometry.Get())) };
+        return { MultiLineString::convert(env, jni::Cast(env, jni::Class<MultiLineString>::Singleton(env), jGeometry)) };
     } else if (type == Polygon::Type()) {
-        return { Polygon::convert(env, jni::Object<Polygon>(jGeometry.Get())) };
+        return { Polygon::convert(env, jni::Cast(env, jni::Class<Polygon>::Singleton(env), jGeometry)) };
     } else if (type == MultiPolygon::Type()) {
-        return { MultiPolygon::convert(env, jni::Object<MultiPolygon>(jGeometry.Get())) };
+        return { MultiPolygon::convert(env, jni::Cast(env, jni::Class<MultiPolygon>::Singleton(env), jGeometry)) };
     } else if (type == GeometryCollection::Type()) {
-        return { GeometryCollection::convert(env, jni::Object<GeometryCollection>(jGeometry.Get())) };
+        return { GeometryCollection::convert(env, jni::Cast(env, jni::Class<GeometryCollection>::Singleton(env), jGeometry)) };
     }
 
     throw std::runtime_error(std::string {"Unsupported GeoJSON type: " } + type);
 }
 
-std::string Geometry::getType(jni::JNIEnv &env, jni::Object<Geometry> jGeometry) {
-    static auto method = Geometry::javaClass.GetMethod<jni::String ()>(env, "type");
-    auto jType = jGeometry.Call(env, method);
-    auto type = jni::Make<std::string>(env, jType);
-    jni::DeleteLocalRef(env, jType);
-    return type;
+std::string Geometry::getType(jni::JNIEnv &env, const jni::Object<Geometry>& jGeometry) {
+    static auto& javaClass = jni::Class<Geometry>::Singleton(env);
+    static auto method = javaClass.GetMethod<jni::String ()>(env, "type");
+    return jni::Make<std::string>(env, jGeometry.Call(env, method));
 }
 
 void Geometry::registerNative(jni::JNIEnv &env) {
-    // Lookup the class
-    javaClass = *jni::Class<Geometry>::Find(env).NewGlobalRef(env).release();
+    jni::Class<Geometry>::Singleton(env);
 }
 
-jni::Class<Geometry> Geometry::javaClass;
-
 } // namespace geojson
 } // namespace android
 } // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/geojson/geometry.hpp b/platform/android/src/geojson/geometry.hpp
index a1bb886683..4bf55c858b 100644
--- a/platform/android/src/geojson/geometry.hpp
+++ b/platform/android/src/geojson/geometry.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
 #include <mbgl/util/geometry.hpp>
-#include <mbgl/util/noncopyable.hpp>
 
 #include "../java/util.hpp"
 
@@ -11,17 +10,15 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-class Geometry : private mbgl::util::noncopyable {
+class Geometry {
 public:
     static constexpr auto Name() { return "com/mapbox/geojson/Geometry"; };
 
-    static jni::Object<Geometry> New(jni::JNIEnv&, mbgl::Geometry<double>);
+    static jni::Local<jni::Object<Geometry>> New(jni::JNIEnv&, mbgl::Geometry<double>);
 
-    static mbgl::Geometry<double> convert(jni::JNIEnv&, jni::Object<Geometry>);
+    static mbgl::Geometry<double> convert(jni::JNIEnv&, const jni::Object<Geometry>&);
 
-    static std::string getType(jni::JNIEnv&, jni::Object<Geometry>);
-
-    static jni::Class<Geometry> javaClass;
+    static std::string getType(jni::JNIEnv&, const jni::Object<Geometry>&);
 
     static void registerNative(jni::JNIEnv&);
 };
diff --git a/platform/android/src/geojson/geometry_collection.cpp b/platform/android/src/geojson/geometry_collection.cpp
index 770cb9a5d6..cca909126d 100644
--- a/platform/android/src/geojson/geometry_collection.cpp
+++ b/platform/android/src/geojson/geometry_collection.cpp
@@ -5,59 +5,43 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-jni::Object<GeometryCollection> GeometryCollection::New(jni::JNIEnv& env, const mapbox::geometry::geometry_collection<double>& collection) {
+jni::Local<jni::Object<GeometryCollection>> GeometryCollection::New(jni::JNIEnv& env, const mapbox::geometry::geometry_collection<double>& collection) {
     // Create an array of geometries
-    auto jarray = jni::Array<jni::Object<Geometry>>::New(env, collection.size(), Geometry::javaClass);
+    auto jarray = jni::Array<jni::Object<Geometry>>::New(env, collection.size());
 
     for (size_t i = 0; i < collection.size(); i++) {
-        auto& geometry = collection.at(i);
-        auto jGeometry = Geometry::New(env, geometry);
-        jarray.Set(env, i, jGeometry);
-        jni::DeleteLocalRef(env, jGeometry);
+        jarray.Set(env, i, Geometry::New(env, collection.at(i)));
     }
 
-    // Turn into array list
-    auto jList = java::util::Arrays::asList(env, jarray);
-    jni::DeleteLocalRef(env, jarray);
-
     // create the GeometryCollection
+    static auto& javaClass = jni::Class<GeometryCollection>::Singleton(env);
     static auto method = javaClass.GetStaticMethod<jni::Object<GeometryCollection> (jni::Object<java::util::List>)>(env, "fromGeometries");
-    auto jCollection = javaClass.Call(env, method, jList);
-
-    jni::DeleteLocalRef(env, jList);
-    return jCollection;
+    return javaClass.Call(env, method, java::util::Arrays::asList(env, jarray));
 }
 
-mapbox::geometry::geometry_collection<double> GeometryCollection::convert(jni::JNIEnv &env, jni::Object<GeometryCollection> jCollection) {
+mapbox::geometry::geometry_collection<double> GeometryCollection::convert(jni::JNIEnv &env, const jni::Object<GeometryCollection>& jCollection) {
     // Get geometries
+    static auto& javaClass = jni::Class<GeometryCollection>::Singleton(env);
     static auto getGeometries = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "geometries");
-    auto jList = jCollection.Call(env, getGeometries);
 
     // Turn into array
-    auto jarray = java::util::List::toArray<Geometry>(env, jList);
-    jni::DeleteLocalRef(env, jList);
+    auto jarray = java::util::List::toArray<Geometry>(env, jCollection.Call(env, getGeometries));
 
     // Convert each geometry
     mapbox::geometry::geometry_collection<double> collection{};
 
     auto size = jarray.Length(env);
     for (jni::jsize i = 0; i < size; i++) {
-        auto element = jarray.Get(env, i);
-        collection.push_back(Geometry::convert(env, element));
-        jni::DeleteLocalRef(env, element);
+        collection.push_back(Geometry::convert(env, jarray.Get(env, i)));
     }
 
-    jni::DeleteLocalRef(env, jarray);
     return collection;
 }
 
 void GeometryCollection::registerNative(jni::JNIEnv &env) {
-    // Lookup the class
-    javaClass = *jni::Class<GeometryCollection>::Find(env).NewGlobalRef(env).release();
+    jni::Class<GeometryCollection>::Singleton(env);
 }
 
-jni::Class<GeometryCollection> GeometryCollection::javaClass;
-
 } // namespace geojson
 } // namespace android
 } // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/geojson/geometry_collection.hpp b/platform/android/src/geojson/geometry_collection.hpp
index 9ed9953b0d..9f02ac848d 100644
--- a/platform/android/src/geojson/geometry_collection.hpp
+++ b/platform/android/src/geojson/geometry_collection.hpp
@@ -8,17 +8,15 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-class GeometryCollection : public Geometry {
+class GeometryCollection {
 public:
+    using SuperTag = Geometry;
     static constexpr auto Name() { return "com/mapbox/geojson/GeometryCollection"; };
-
     static constexpr auto Type() { return "GeometryCollection"; };
 
-    static jni::Object<GeometryCollection> New(jni::JNIEnv&, const mapbox::geometry::geometry_collection<double>&);
-
-    static mapbox::geometry::geometry_collection<double> convert(jni::JNIEnv&, jni::Object<GeometryCollection>);
+    static jni::Local<jni::Object<GeometryCollection>> New(jni::JNIEnv&, const mapbox::geometry::geometry_collection<double>&);
 
-    static jni::Class<GeometryCollection> javaClass;
+    static mapbox::geometry::geometry_collection<double> convert(jni::JNIEnv&, const jni::Object<GeometryCollection>&);
 
     static void registerNative(jni::JNIEnv&);
 };
diff --git a/platform/android/src/geojson/line_string.cpp b/platform/android/src/geojson/line_string.cpp
index a5f1a468ce..ae1345c958 100644
--- a/platform/android/src/geojson/line_string.cpp
+++ b/platform/android/src/geojson/line_string.cpp
@@ -7,29 +7,24 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-jni::Object<LineString> LineString::New(jni::JNIEnv& env, const mbgl::LineString<double>& lineString) {
-    auto jList = asPointsList(env, lineString);
-
+jni::Local<jni::Object<LineString>> LineString::New(jni::JNIEnv& env, const mbgl::LineString<double>& lineString) {
+    static auto& javaClass = jni::Class<LineString>::Singleton(env);
     static auto method = javaClass.GetStaticMethod<jni::Object<LineString>(jni::Object<java::util::List>)>(env, "fromLngLats");
-    auto jLineString = javaClass.Call(env, method, jList);
 
-    jni::DeleteLocalRef(env, jList);
-    return jLineString;
+    return javaClass.Call(env, method, asPointsList(env, lineString));
 }
 
-mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, jni::Object<LineString> jLineString) {
+mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, const jni::Object<LineString>& jLineString) {
     mapbox::geojson::line_string lineString;
 
     if (jLineString) {
-        auto jPointList = LineString::coordinates(env, jLineString);
-        lineString = LineString::convert(env, jPointList);
-        jni::DeleteLocalRef(env, jPointList);
+        lineString = LineString::convert(env, LineString::coordinates(env, jLineString));
     }
 
     return lineString;
 }
 
-mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, jni::Object<java::util::List/*<Point>*/> jPointList) {
+mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, const jni::Object<java::util::List/*<Point>*/>& jPointList) {
     mapbox::geojson::line_string lineString;
 
     if (jPointList) {
@@ -38,29 +33,23 @@ mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, jni::Object<j
         lineString.reserve(size);
 
         for (std::size_t i = 0; i < size; i++) {
-            auto jPoint = jPointArray.Get(env, i);
-            lineString.push_back(Point::convert(env, jPoint));
-            jni::DeleteLocalRef(env, jPoint);
+            lineString.push_back(Point::convert(env, jPointArray.Get(env, i)));
         }
-
-        jni::DeleteLocalRef(env, jPointArray);
     }
 
     return lineString;
 }
 
-jni::Object<java::util::List> LineString::coordinates(jni::JNIEnv &env, jni::Object<LineString> jLineString) {
-    static auto method = LineString::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
+jni::Local<jni::Object<java::util::List>> LineString::coordinates(jni::JNIEnv &env, const jni::Object<LineString>& jLineString) {
+    static auto& javaClass = jni::Class<LineString>::Singleton(env);
+    static auto method = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
     return jLineString.Call(env, method);
 }
 
 void LineString::registerNative(jni::JNIEnv &env) {
-    // Lookup the class
-    javaClass = *jni::Class<LineString>::Find(env).NewGlobalRef(env).release();
+    jni::Class<LineString>::Singleton(env);
 }
 
-jni::Class<LineString> LineString::javaClass;
-
 } // namespace geojson
 } // namespace android
 } // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/geojson/line_string.hpp b/platform/android/src/geojson/line_string.hpp
index 98dc414642..906d809fa8 100644
--- a/platform/android/src/geojson/line_string.hpp
+++ b/platform/android/src/geojson/line_string.hpp
@@ -14,21 +14,19 @@ namespace android {
 namespace geojson {
 
 
-class LineString : public Geometry {
+class LineString {
 public:
+    using SuperTag = Geometry;
     static constexpr auto Name() { return "com/mapbox/geojson/LineString"; };
-
     static constexpr auto Type() { return "LineString"; };
 
-    static jni::Object<LineString> New(jni::JNIEnv&, const mbgl::LineString<double>&);
-
-    static mapbox::geojson::line_string convert(jni::JNIEnv&, jni::Object<LineString>);
+    static jni::Local<jni::Object<LineString>> New(jni::JNIEnv&, const mbgl::LineString<double>&);
 
-    static mapbox::geojson::line_string convert(jni::JNIEnv&, jni::Object<java::util::List/*<Point>*/>);
+    static mapbox::geojson::line_string convert(jni::JNIEnv&, const jni::Object<LineString>&);
 
-    static jni::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<LineString>);
+    static mapbox::geojson::line_string convert(jni::JNIEnv&, const jni::Object<java::util::List/*<Point>*/>&);
 
-    static jni::Class<LineString> javaClass;
+    static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv&, const jni::Object<LineString>&);
 
     static void registerNative(jni::JNIEnv&);
 };
diff --git a/platform/android/src/geojson/multi_line_string.cpp b/platform/android/src/geojson/multi_line_string.cpp
index 4a6ea37dd1..1aaf53c01f 100644
--- a/platform/android/src/geojson/multi_line_string.cpp
+++ b/platform/android/src/geojson/multi_line_string.cpp
@@ -7,29 +7,24 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-jni::Object<MultiLineString> MultiLineString::New(jni::JNIEnv& env, const mbgl::MultiLineString<double>& multiLineString) {
-    auto jList = asPointsListsList(env, multiLineString);
-
+jni::Local<jni::Object<MultiLineString>> MultiLineString::New(jni::JNIEnv& env, const mbgl::MultiLineString<double>& multiLineString) {
+    static auto& javaClass = jni::Class<MultiLineString>::Singleton(env);
     static auto method = javaClass.GetStaticMethod<jni::Object<MultiLineString> (jni::Object<java::util::List>)>(env, "fromLngLats");
-    auto jMultiLineString = javaClass.Call(env, method, jList);
 
-    jni::DeleteLocalRef(env, jList);
-    return jMultiLineString;
+    return javaClass.Call(env, method, asPointsListsList(env, multiLineString));
 }
 
-mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv &env, jni::Object<MultiLineString> jMultiLineString) {
+mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv &env, const jni::Object<MultiLineString>& jMultiLineString) {
     mapbox::geojson::multi_line_string multiLineString;
 
     if (jMultiLineString) {
-        auto jPointListsList = MultiLineString::coordinates(env, jMultiLineString);
-        multiLineString = MultiLineString::convert(env, jPointListsList);
-        jni::DeleteLocalRef(env, jPointListsList);
+        multiLineString = MultiLineString::convert(env, MultiLineString::coordinates(env, jMultiLineString));
     }
 
     return multiLineString;
 }
 
-mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv &env, jni::Object<java::util::List/*<java::util::List<Point>>*/> jPointListsList) {
+mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv &env, const jni::Object<java::util::List/*<java::util::List<Point>>*/>& jPointListsList) {
     mapbox::geojson::multi_line_string multiLineString;
 
     if (jPointListsList) {
@@ -39,29 +34,23 @@ mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv &env, jn
         multiLineString.reserve(size);
 
         for (std::size_t i = 0; i < size; i++) {
-            auto jPointsList = jPositionListsArray.Get(env, i);
-            multiLineString.push_back(LineString::convert(env, jPointsList));
-            jni::DeleteLocalRef(env, jPointsList);
+            multiLineString.push_back(LineString::convert(env, jPositionListsArray.Get(env, i)));
         }
-
-        jni::DeleteLocalRef(env, jPositionListsArray);
     }
 
     return multiLineString;
 }
 
-jni::Object<java::util::List> MultiLineString::coordinates(jni::JNIEnv &env, jni::Object<MultiLineString> jLineString) {
-    static auto method = MultiLineString::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
+jni::Local<jni::Object<java::util::List>> MultiLineString::coordinates(jni::JNIEnv &env, const jni::Object<MultiLineString>& jLineString) {
+    static auto& javaClass = jni::Class<MultiLineString>::Singleton(env);
+    static auto method = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
     return jLineString.Call(env, method);
 }
 
 void MultiLineString::registerNative(jni::JNIEnv &env) {
-    // Lookup the class
-    javaClass = *jni::Class<MultiLineString>::Find(env).NewGlobalRef(env).release();
+    jni::Class<MultiLineString>::Singleton(env);
 }
 
-jni::Class<MultiLineString> MultiLineString::javaClass;
-
 } // namespace geojson
 } // namespace android
 } // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/geojson/multi_line_string.hpp b/platform/android/src/geojson/multi_line_string.hpp
index 934a0cb6b5..65ce43bd1f 100644
--- a/platform/android/src/geojson/multi_line_string.hpp
+++ b/platform/android/src/geojson/multi_line_string.hpp
@@ -12,21 +12,19 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-class MultiLineString : public Geometry {
+class MultiLineString {
 public:
+    using SuperTag = Geometry;
     static constexpr auto Name() { return "com/mapbox/geojson/MultiLineString"; };
-
     static constexpr auto Type() { return "MultiLineString"; };
 
-    static jni::Object<MultiLineString> New(jni::JNIEnv&, const mbgl::MultiLineString<double>&);
-
-    static mapbox::geojson::multi_line_string convert(jni::JNIEnv&, jni::Object<MultiLineString>);
+    static jni::Local<jni::Object<MultiLineString>> New(jni::JNIEnv&, const mbgl::MultiLineString<double>&);
 
-    static mapbox::geojson::multi_line_string convert(jni::JNIEnv&, jni::Object<java::util::List/*<java::util::List<Point>>*/>);
+    static mapbox::geojson::multi_line_string convert(jni::JNIEnv&, const jni::Object<MultiLineString>&);
 
-    static jni::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<MultiLineString>);
+    static mapbox::geojson::multi_line_string convert(jni::JNIEnv&, const jni::Object<java::util::List/*<java::util::List<Point>>*/>&);
 
-    static jni::Class<MultiLineString> javaClass;
+    static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv&, const jni::Object<MultiLineString>&);
 
     static void registerNative(jni::JNIEnv&);
 };
diff --git a/platform/android/src/geojson/multi_point.cpp b/platform/android/src/geojson/multi_point.cpp
index 6f62541209..d530ef721f 100644
--- a/platform/android/src/geojson/multi_point.cpp
+++ b/platform/android/src/geojson/multi_point.cpp
@@ -8,40 +8,34 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-jni::Object<MultiPoint> MultiPoint::New(JNIEnv& env, const mbgl::MultiPoint<double>& multiPoint) {
-    auto jList = asPointsList(env, multiPoint);
-
+jni::Local<jni::Object<MultiPoint>> MultiPoint::New(JNIEnv& env, const mbgl::MultiPoint<double>& multiPoint) {
+    static auto& javaClass = jni::Class<MultiPoint>::Singleton(env);
     static auto method = javaClass.GetStaticMethod<jni::Object<MultiPoint>(jni::Object<java::util::List>)>(env, "fromLngLats");
-    auto jMultiPoint = javaClass.Call(env, method, jList);
 
-    jni::DeleteLocalRef(env, jList);
-    return jMultiPoint;
+    return javaClass.Call(env, method, asPointsList(env, multiPoint));
 }
 
-mapbox::geojson::multi_point MultiPoint::convert(jni::JNIEnv &env, jni::Object<MultiPoint> jMultiPoint) {
+mapbox::geojson::multi_point MultiPoint::convert(jni::JNIEnv& env, const jni::Object<MultiPoint>& jMultiPoint) {
     mapbox::geojson::multi_point multiPoint;
 
     if (jMultiPoint) {
-        auto jPointListsList = MultiPoint::coordinates(env, jMultiPoint);
-        multiPoint = convertExplicit<mapbox::geojson::multi_point>(LineString::convert(env, jPointListsList));
-        jni::DeleteLocalRef(env, jPointListsList);
+        multiPoint = convertExplicit<mapbox::geojson::multi_point>(
+            LineString::convert(env, MultiPoint::coordinates(env, jMultiPoint)));
     }
 
     return multiPoint;
 }
 
-jni::Object<java::util::List> MultiPoint::coordinates(jni::JNIEnv &env, jni::Object<MultiPoint> jMultiPoint) {
-    static auto method = MultiPoint::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
+jni::Local<jni::Object<java::util::List>> MultiPoint::coordinates(jni::JNIEnv& env, const jni::Object<MultiPoint>& jMultiPoint) {
+    static auto& javaClass = jni::Class<MultiPoint>::Singleton(env);
+    static auto method = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
     return jMultiPoint.Call(env, method);
 }
 
 void MultiPoint::registerNative(jni::JNIEnv &env) {
-    // Lookup the class
-    javaClass = *jni::Class<MultiPoint>::Find(env).NewGlobalRef(env).release();
+    jni::Class<MultiPoint>::Singleton(env);
 }
 
-jni::Class<MultiPoint> MultiPoint::javaClass;
-
 } // namespace geojson
 } // namespace android
 } // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/geojson/multi_point.hpp b/platform/android/src/geojson/multi_point.hpp
index cfe80cd34c..a3ca49b731 100644
--- a/platform/android/src/geojson/multi_point.hpp
+++ b/platform/android/src/geojson/multi_point.hpp
@@ -13,19 +13,17 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-class MultiPoint : public Geometry {
+class MultiPoint {
 public:
+    using SuperTag = Geometry;
     static constexpr auto Name() { return "com/mapbox/geojson/MultiPoint"; };
-
     static constexpr auto Type() { return "MultiPoint"; };
 
-    static jni::Object<MultiPoint> New(jni::JNIEnv&, const mbgl::MultiPoint<double>&);
-
-    static mapbox::geojson::multi_point convert(jni::JNIEnv&, jni::Object<MultiPoint>);
+    static jni::Local<jni::Object<MultiPoint>> New(jni::JNIEnv&, const mbgl::MultiPoint<double>&);
 
-    static jni::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<MultiPoint>);
+    static mapbox::geojson::multi_point convert(jni::JNIEnv&, const jni::Object<MultiPoint>&);
 
-    static jni::Class<MultiPoint> javaClass;
+    static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv&, const jni::Object<MultiPoint>&);
 
     static void registerNative(jni::JNIEnv&);
 };
diff --git a/platform/android/src/geojson/multi_polygon.cpp b/platform/android/src/geojson/multi_polygon.cpp
index cc872d4955..3c5c3ec338 100644
--- a/platform/android/src/geojson/multi_polygon.cpp
+++ b/platform/android/src/geojson/multi_polygon.cpp
@@ -7,29 +7,20 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-jni::Object<MultiPolygon> MultiPolygon::New(JNIEnv& env, const mbgl::MultiPolygon<double>& multiPolygon) {
-    auto jarray = jni::Array<jni::Object<java::util::List>>::New(env, multiPolygon.size(), java::util::List::javaClass);
+jni::Local<jni::Object<MultiPolygon>> MultiPolygon::New(JNIEnv& env, const mbgl::MultiPolygon<double>& multiPolygon) {
+    static auto& javaClass = jni::Class<MultiPolygon>::Singleton(env);
+    static auto method = javaClass.GetStaticMethod<jni::Object<MultiPolygon> (jni::Object<java::util::List>)>(env, "fromLngLats");
+
+    auto jarray = jni::Array<jni::Object<java::util::List>>::New(env, multiPolygon.size());
 
     for (size_t i = 0; i < multiPolygon.size(); i++) {
-        auto& geometry = multiPolygon.at(i);
-        auto jPolygon = asPointsListsList(env, geometry);
-        jarray.Set(env, i, jPolygon);
-        jni::DeleteLocalRef(env, jPolygon);
+        jarray.Set(env, i, asPointsListsList(env, multiPolygon.at(i)));
     }
 
-    // Turn into array list
-    auto jList = java::util::Arrays::asList(env, jarray);
-    jni::DeleteLocalRef(env, jarray);
-
-    // create the MultiPolygon
-    static auto method = javaClass.GetStaticMethod<jni::Object<MultiPolygon> (jni::Object<java::util::List>)>(env, "fromLngLats");
-    auto jMultiPolygon = javaClass.Call(env, method, jList);
-
-    jni::DeleteLocalRef(env, jList);
-    return jMultiPolygon;
+    return javaClass.Call(env, method, java::util::Arrays::asList(env, jarray));
 }
 
-mapbox::geojson::multi_polygon MultiPolygon::convert(jni::JNIEnv &env, jni::Object<MultiPolygon> jMultiPolygon) {
+mapbox::geojson::multi_polygon MultiPolygon::convert(jni::JNIEnv& env, const jni::Object<MultiPolygon>& jMultiPolygon) {
     mapbox::geojson::multi_polygon multiPolygon;
 
     if (jMultiPolygon) {
@@ -40,30 +31,23 @@ mapbox::geojson::multi_polygon MultiPolygon::convert(jni::JNIEnv &env, jni::Obje
         multiPolygon.reserve(size);
 
         for (size_t i = 0; i < size; i++) {
-            auto jPositionListsList = jPointListsListArray.Get(env, i);
-            multiPolygon.push_back(Polygon::convert(env, jPositionListsList));
-            jni::DeleteLocalRef(env, jPositionListsList);
+            multiPolygon.push_back(Polygon::convert(env, jPointListsListArray.Get(env, i)));
         }
-
-        jni::DeleteLocalRef(env, jPointListsListArray);
-        jni::DeleteLocalRef(env, jPointListsListList);
     }
 
     return multiPolygon;
 }
 
-jni::Object<java::util::List> MultiPolygon::coordinates(jni::JNIEnv &env, jni::Object<MultiPolygon> jPolygon) {
-    static auto method = MultiPolygon::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
+jni::Local<jni::Object<java::util::List>> MultiPolygon::coordinates(jni::JNIEnv& env, const jni::Object<MultiPolygon>& jPolygon) {
+    static auto& javaClass = jni::Class<MultiPolygon>::Singleton(env);
+    static auto method = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
     return jPolygon.Call(env, method);
 }
 
 void MultiPolygon::registerNative(jni::JNIEnv &env) {
-    // Lookup the class
-    javaClass = *jni::Class<MultiPolygon>::Find(env).NewGlobalRef(env).release();
+    jni::Class<MultiPolygon>::Singleton(env);
 }
 
-jni::Class<MultiPolygon> MultiPolygon::javaClass;
-
 } // namespace geojson
 } // namespace android
 } // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/geojson/multi_polygon.hpp b/platform/android/src/geojson/multi_polygon.hpp
index b4657af09d..fd7b08016d 100644
--- a/platform/android/src/geojson/multi_polygon.hpp
+++ b/platform/android/src/geojson/multi_polygon.hpp
@@ -12,19 +12,17 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-class MultiPolygon : public Geometry {
+class MultiPolygon {
 public:
+    using SuperTag = Geometry;
     static constexpr auto Name() { return "com/mapbox/geojson/MultiPolygon"; };
-
     static constexpr auto Type() { return "MultiPolygon"; };
 
-    static jni::Object<MultiPolygon> New(jni::JNIEnv&, const mbgl::MultiPolygon<double>&);
-
-    static mapbox::geojson::multi_polygon convert(jni::JNIEnv&, jni::Object<MultiPolygon>);
+    static jni::Local<jni::Object<MultiPolygon>> New(jni::JNIEnv&, const mbgl::MultiPolygon<double>&);
 
-    static jni::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<MultiPolygon>);
+    static mapbox::geojson::multi_polygon convert(jni::JNIEnv&, const jni::Object<MultiPolygon>&);
 
-    static jni::Class<MultiPolygon> javaClass;
+    static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv&, const jni::Object<MultiPolygon>&);
 
     static void registerNative(jni::JNIEnv&);
 };
diff --git a/platform/android/src/geojson/point.cpp b/platform/android/src/geojson/point.cpp
index 8a9656ea14..2000447c0f 100644
--- a/platform/android/src/geojson/point.cpp
+++ b/platform/android/src/geojson/point.cpp
@@ -1,62 +1,34 @@
 #include "point.hpp"
-#include "../java/util.hpp"
-#include "../java_types.hpp"
-#include "../style/value.hpp"
 
 namespace mbgl {
 namespace android {
 namespace geojson {
 
-jni::Object<Point> Point::New(jni::JNIEnv& env, const mbgl::Point<double>& point) {
+jni::Local<jni::Object<Point>> Point::New(jni::JNIEnv& env, const mbgl::Point<double>& point) {
+    static auto& javaClass = jni::Class<Point>::Singleton(env);
     static auto method = javaClass.GetStaticMethod<jni::Object<Point> (jni::jdouble, jni::jdouble)>(env, "fromLngLat");
     return javaClass.Call(env, method, point.x, point.y);
 }
 
-mapbox::geojson::point Point::convert(jni::JNIEnv &env, jni::Object<Point> jPoint) {
-    mapbox::geojson::point point;
+mbgl::Point<double> Point::convert(jni::JNIEnv &env, const jni::Object<Point>& jPoint) {
+    static auto& javaClass = jni::Class<Point>::Singleton(env);
+    static auto longitude = javaClass.GetMethod<jni::jdouble ()>(env, "longitude");
+    static auto latitude = javaClass.GetMethod<jni::jdouble ()>(env, "latitude");
 
-    if (jPoint) {
-        auto jDoubleList = Point::coordinates(env, jPoint);
-        point = Point::convert(env, jDoubleList);
-        jni::DeleteLocalRef(env, jDoubleList);
+    if (!jPoint) {
+        return {};
     }
 
-    return point;
-}
-
-mapbox::geojson::point Point::convert(jni::JNIEnv &env, jni::Object<java::util::List/*<Double>*/> jDoubleList) {
-    mapbox::geojson::point point;
-
-    if (jDoubleList) {
-        auto jDoubleArray = java::util::List::toArray<jobject>(env, jDoubleList);
-
-        auto lonObject = jDoubleArray.Get(env, 0);
-        auto latObject = jDoubleArray.Get(env, 1);
-
-        point.x = jni::CallMethod<jni::jdouble>(env, lonObject,
-                                                *java::Number::doubleValueMethodId);
-        point.y = jni::CallMethod<jni::jdouble>(env, latObject,
-                                                *java::Number::doubleValueMethodId);
-
-        jni::DeleteLocalRef(env, lonObject);
-        jni::DeleteLocalRef(env, latObject);
-        jni::DeleteLocalRef(env, jDoubleArray);
-    }
-    return point;
-}
-
-jni::Object<java::util::List> Point::coordinates(jni::JNIEnv &env, jni::Object<Point> jPoint) {
-     static auto method = Point::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
-     return jPoint.Call(env, method);
+    return {
+        jPoint.Call(env, longitude),
+        jPoint.Call(env, latitude)
+    };
 }
 
 void Point::registerNative(jni::JNIEnv &env) {
-    // Lookup the class
-    javaClass = *jni::Class<Point>::Find(env).NewGlobalRef(env).release();
+    jni::Class<Point>::Singleton(env);
 }
 
-jni::Class<Point> Point::javaClass;
-
 } // namespace geojson
 } // namespace android
 } // namespace mbgl
diff --git a/platform/android/src/geojson/point.hpp b/platform/android/src/geojson/point.hpp
index 627bd1b649..b5d71ecae1 100644
--- a/platform/android/src/geojson/point.hpp
+++ b/platform/android/src/geojson/point.hpp
@@ -1,9 +1,7 @@
 #pragma once
 
-#include <mbgl/util/geojson.hpp>
-#include <mbgl/util/noncopyable.hpp>
+#include <mbgl/util/geometry.hpp>
 
-#include "../java/util.hpp"
 #include "geometry.hpp"
 
 #include <jni/jni.hpp>
@@ -12,21 +10,14 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-class Point : public Geometry {
+class Point {
 public:
+    using SuperTag = Geometry;
     static constexpr auto Name() { return "com/mapbox/geojson/Point"; };
-
     static constexpr auto Type() { return "Point"; };
 
-    static jni::Object<Point> New(jni::JNIEnv&, const mbgl::Point<double>&);
-
-    static mapbox::geojson::point convert(jni::JNIEnv&, jni::Object<Point>);
-
-    static mapbox::geojson::point convert(jni::JNIEnv&, jni::Object<java::util::List/*<Double>*/>);
-
-    static jni::Object<java::util::List> coordinates(JNIEnv&, jni::Object<Point>);
-
-    static jni::Class<Point> javaClass;
+    static jni::Local<jni::Object<Point>> New(jni::JNIEnv&, const mbgl::Point<double>&);
+    static mbgl::Point<double> convert(jni::JNIEnv&, const jni::Object<Point>&);
 
     static void registerNative(jni::JNIEnv&);
 };
diff --git a/platform/android/src/geojson/polygon.cpp b/platform/android/src/geojson/polygon.cpp
index 96058b63b3..4437d134a8 100644
--- a/platform/android/src/geojson/polygon.cpp
+++ b/platform/android/src/geojson/polygon.cpp
@@ -8,29 +8,24 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-jni::Object<Polygon> Polygon::New(jni::JNIEnv& env, const mbgl::Polygon<double>& polygon) {
-    auto jList = asPointsListsList(env, polygon);
-
+jni::Local<jni::Object<Polygon>> Polygon::New(jni::JNIEnv& env, const mbgl::Polygon<double>& polygon) {
+    static auto& javaClass = jni::Class<Polygon>::Singleton(env);
     static auto method = javaClass.GetStaticMethod<jni::Object<Polygon> (jni::Object<java::util::List>)>(env, "fromLngLats");
-    auto jPolygon = javaClass.Call(env, method, jList);
 
-    jni::DeleteLocalRef(env, jList);
-    return jPolygon;
+    return javaClass.Call(env, method, asPointsListsList(env, polygon));
 }
 
-mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, jni::Object<Polygon> jPolygon) {
+mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, const jni::Object<Polygon>& jPolygon) {
     mapbox::geojson::polygon polygon;
 
     if (jPolygon) {
-        auto jPositionListsList = Polygon::coordinates(env, jPolygon);
-        polygon = Polygon::convert(env, jPositionListsList);
-        jni::DeleteLocalRef(env, jPositionListsList);
+        polygon = Polygon::convert(env, Polygon::coordinates(env, jPolygon));
     }
 
     return polygon;
 }
 
-mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, jni::Object<java::util::List/*<java::util::List<Point>>*/> jPointListsList) {
+mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, const jni::Object<java::util::List/*<java::util::List<Point>>*/>& jPointListsList) {
     mapbox::geojson::polygon polygon;
 
     if (jPointListsList) {
@@ -45,18 +40,16 @@ mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, jni::Object<java::ut
 }
 
 
-jni::Object<java::util::List> Polygon::coordinates(jni::JNIEnv &env, jni::Object<Polygon> jPolygon) {
-    static auto method = Polygon::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
+jni::Local<jni::Object<java::util::List>> Polygon::coordinates(jni::JNIEnv &env, const jni::Object<Polygon>& jPolygon) {
+    static auto& javaClass = jni::Class<Polygon>::Singleton(env);
+    static auto method = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
     return jPolygon.Call(env, method);
 }
 
 void Polygon::registerNative(jni::JNIEnv &env) {
-    // Lookup the class
-    javaClass = *jni::Class<Polygon>::Find(env).NewGlobalRef(env).release();
+    jni::Class<Polygon>::Singleton(env);
 }
 
-jni::Class<Polygon> Polygon::javaClass;
-
 } // namespace geojson
 } // namespace android
 } // namespace mbgl
\ No newline at end of file
diff --git a/platform/android/src/geojson/polygon.hpp b/platform/android/src/geojson/polygon.hpp
index f3c23b4d7b..8e1761feda 100644
--- a/platform/android/src/geojson/polygon.hpp
+++ b/platform/android/src/geojson/polygon.hpp
@@ -13,21 +13,19 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-class Polygon : public Geometry {
+class Polygon {
 public:
+    using SuperTag = Geometry;
     static constexpr auto Name() { return "com/mapbox/geojson/Polygon"; };
-
     static constexpr auto Type() { return "Polygon"; };
 
-    static jni::Object<Polygon> New(jni::JNIEnv&, const mbgl::Polygon<double>&);
-
-    static mapbox::geojson::polygon convert(jni::JNIEnv &, jni::Object<Polygon>);
+    static jni::Local<jni::Object<Polygon>> New(jni::JNIEnv&, const mbgl::Polygon<double>&);
 
-    static mapbox::geojson::polygon convert(jni::JNIEnv&, jni::Object<java::util::List/*<java::util::List<Point>>*/>);
+    static mapbox::geojson::polygon convert(jni::JNIEnv &, const jni::Object<Polygon>&);
 
-    static jni::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<Polygon>);
+    static mapbox::geojson::polygon convert(jni::JNIEnv&, const jni::Object<java::util::List/*<java::util::List<Point>>*/>&);
 
-    static jni::Class<Polygon> javaClass;
+    static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv&, const jni::Object<Polygon>&);
 
     static void registerNative(jni::JNIEnv &);
 };
diff --git a/platform/android/src/geojson/util.hpp b/platform/android/src/geojson/util.hpp
index 5e6d90a953..59154516fa 100644
--- a/platform/android/src/geojson/util.hpp
+++ b/platform/android/src/geojson/util.hpp
@@ -23,36 +23,28 @@ To convertExplicit(From&& src) {
  *  Geometry -> List<Point>
  */
 template <class T>
-static jni::Object<java::util::List> asPointsList(jni::JNIEnv& env, const T& pointsList) {
-    auto jarray = jni::Array<jni::Object<Point>>::New(env, pointsList.size(), Point::javaClass);
+static jni::Local<jni::Object<java::util::List>> asPointsList(jni::JNIEnv& env, const T& pointsList) {
+    auto jarray = jni::Array<jni::Object<Point>>::New(env, pointsList.size());
 
     for (jni::jsize i = 0; i < pointsList.size(); i++) {
-        auto jPoint = Point::New(env, pointsList.at(i));
-        jarray.Set(env, i, jPoint);
-        jni::DeleteLocalRef(env, jPoint);
+        jarray.Set(env, i, Point::New(env, pointsList.at(i)));
     }
 
-    auto jList = java::util::Arrays::asList(env, jarray);
-    jni::DeleteLocalRef(env, jarray);
-    return jList;
+    return java::util::Arrays::asList(env, jarray);
 }
 
 /**
  *  Geometry -> List<List<Point>>
  */
 template <class SHAPE>
-static jni::Object<java::util::List> asPointsListsList(JNIEnv& env, SHAPE value) {
-    auto jarray = jni::Array<jni::Object<java::util::List>>::New(env, value.size(), java::util::List::javaClass);
+static jni::Local<jni::Object<java::util::List>> asPointsListsList(JNIEnv& env, const SHAPE& value) {
+    auto jarray = jni::Array<jni::Object<java::util::List>>::New(env, value.size());
 
-    for (size_t i = 0; i < value.size(); i = i + 1) {
-        auto pointsList = asPointsList(env, value[i]);
-        jarray.Set(env, i, pointsList);
-        jni::DeleteLocalRef(env, pointsList);
+    for (size_t i = 0; i < value.size(); i++) {
+        jarray.Set(env, i, asPointsList(env, value[i]));
     }
 
-    auto jList = java::util::Arrays::asList(env, jarray);
-    jni::DeleteLocalRef(env, jarray);
-    return jList;
+    return java::util::Arrays::asList(env, jarray);
 }
 
 } // namespace geojson