[android] jni.hpp 4.0.0

cmake/mason-dependencies.cmake

@@ -19,7 +19,7 @@ mason_use(cheap-ruler VERSION 2.5.3 HEADER_ONLY)
 mason_use(vector-tile VERSION 1.0.2 HEADER_ONLY)
 
 if(MBGL_PLATFORM STREQUAL "android")
-    mason_use(jni.hpp VERSION 4.0.0-rc8 HEADER_ONLY)
+    mason_use(jni.hpp VERSION 4.0.0 HEADER_ONLY)
 elseif(MBGL_PLATFORM STREQUAL "ios")
     mason_use(icu VERSION 58.1-min-size)
 elseif(MBGL_PLATFORM STREQUAL "linux")

platform/android/scripts/generate-style-code.js

@@ -335,12 +335,8 @@ global.supportsPropertyFunction = function (property) {
 // Template processing //
 
 // Java + JNI Light (Peer model)
-const lightHpp = ejs.compile(fs.readFileSync('platform/android/src/style/light.hpp.ejs', 'utf8'), {strict: true});;
-const lightCpp = ejs.compile(fs.readFileSync('platform/android/src/style/light.cpp.ejs', 'utf8'), {strict: true});;
 const lightJava = ejs.compile(fs.readFileSync('platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/light/light.java.ejs', 'utf8'), {strict: true});
 const lightJavaUnitTests = ejs.compile(fs.readFileSync('platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/light.junit.ejs', 'utf8'), {strict: true});
-writeIfModified(`platform/android/src/style/light.hpp`, lightHpp({properties: lightProperties}));
-writeIfModified(`platform/android/src/style/light.cpp`, lightCpp({properties: lightProperties}));
 writeIfModified(`platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/light/Light.java`, lightJava({properties: lightProperties}));
 writeIfModified(`platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/LightTest.java`, lightJavaUnitTests({properties: lightProperties}));
 

platform/android/src/annotation/marker.cpp

@@ -3,16 +3,16 @@
 namespace mbgl {
 namespace android {
 
-mbgl::Point<double> Marker::getPosition(jni::JNIEnv& env, jni::Object<Marker> marker) {
-    static auto javaClass = jni::Class<Marker>::Singleton(env);
+mbgl::Point<double> Marker::getPosition(jni::JNIEnv& env, const jni::Object<Marker>& marker) {
+    static auto& javaClass = jni::Class<Marker>::Singleton(env);
     static auto positionField = javaClass.GetField<jni::Object<LatLng>>(env, "position");
-    return LatLng::getGeometry(env, *jni::SeizeLocal(env, marker.Get(env, positionField)));
+    return LatLng::getGeometry(env, marker.Get(env, positionField));
 }
 
-std::string Marker::getIconId(jni::JNIEnv& env, jni::Object<Marker> marker) {
-    static auto javaClass = jni::Class<Marker>::Singleton(env);
+std::string Marker::getIconId(jni::JNIEnv& env, const jni::Object<Marker>& marker) {
+    static auto& javaClass = jni::Class<Marker>::Singleton(env);
     static auto iconIdField = javaClass.GetField<jni::String>(env, "iconId");
-    return jni::Make<std::string>(env, *jni::SeizeLocal(env, marker.Get(env, iconIdField)));
+    return jni::Make<std::string>(env, marker.Get(env, iconIdField));
 }
 
 void Marker::registerNative(jni::JNIEnv& env) {

platform/android/src/annotation/marker.hpp

@@ -15,9 +15,9 @@ public:
 
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/annotations/Marker"; };
 
-    static mbgl::Point<double> getPosition(jni::JNIEnv&, jni::Object<Marker>);
+    static mbgl::Point<double> getPosition(jni::JNIEnv&, const jni::Object<Marker>&);
 
-    static std::string getIconId(jni::JNIEnv&, jni::Object<Marker>);
+    static std::string getIconId(jni::JNIEnv&, const jni::Object<Marker>&);
 
     static void registerNative(jni::JNIEnv&);
 

platform/android/src/annotation/multi_point.hpp

@@ -14,16 +14,16 @@ class MultiPoint : protected mbgl::util::noncopyable {
 protected:
 
   template <class Geometry>
-  static Geometry toGeometry(JNIEnv& env, jni::Object<java::util::List> pointsList) {
-      auto jarray = jni::SeizeLocal(env, java::util::List::toArray<LatLng>(env, pointsList));
+  static Geometry toGeometry(JNIEnv& env, const jni::Object<java::util::List>& pointsList) {
+      auto jarray = java::util::List::toArray<LatLng>(env, pointsList);
 
-      std::size_t size = jarray->Length(env);
+      std::size_t size = jarray.Length(env);
 
       Geometry geometry;
       geometry.reserve(size);
 
       for (std::size_t i = 0; i < size; i++) {
-          geometry.push_back(LatLng::getGeometry(env, *jni::SeizeLocal(env, jarray->Get(env, i))));
+          geometry.push_back(LatLng::getGeometry(env, jarray.Get(env, i)));
       }
 
       return geometry;

platform/android/src/annotation/polygon.cpp

@@ -5,8 +5,8 @@
 namespace mbgl {
 namespace android {
 
-mbgl::FillAnnotation Polygon::toAnnotation(jni::JNIEnv& env, jni::Object<Polygon> polygon) {
-    static auto javaClass = jni::Class<Polygon>::Singleton(env);
+mbgl::FillAnnotation Polygon::toAnnotation(jni::JNIEnv& env, const jni::Object<Polygon>& polygon) {
+    static auto& javaClass = jni::Class<Polygon>::Singleton(env);
     static auto points = javaClass.GetField<jni::Object<java::util::List>>(env, "points");
     static auto holes = javaClass.GetField<jni::Object<java::util::List>>(env, "holes");
     static auto alpha = javaClass.GetField<float>(env, "alpha");
@@ -14,17 +14,14 @@ mbgl::FillAnnotation Polygon::toAnnotation(jni::JNIEnv& env, jni::Object<Polygon
     static auto strokeColor = javaClass.GetField<int>(env, "strokeColor");
 
     mbgl::Polygon<double> geometry {
-        MultiPoint::toGeometry<mbgl::LinearRing<double>>(env, *jni::SeizeLocal(env, polygon.Get(env, points)))
+        MultiPoint::toGeometry<mbgl::LinearRing<double>>(env, polygon.Get(env, points))
     };
 
-    auto jHoleListsArray = jni::SeizeLocal(env,
-        java::util::List::toArray<java::util::List>(env,
-            *jni::SeizeLocal(env, polygon.Get(env, holes))));
+    auto jHoleListsArray = java::util::List::toArray<java::util::List>(env, polygon.Get(env, holes));
 
-    std::size_t jHoleListsSize = jHoleListsArray->Length(env);
+    std::size_t jHoleListsSize = jHoleListsArray.Length(env);
     for (std::size_t i = 0; i < jHoleListsSize; i++) {
-        geometry.push_back(MultiPoint::toGeometry<mbgl::LinearRing<double>>(env,
-            *jni::SeizeLocal(env, jHoleListsArray->Get(env, i))));
+        geometry.push_back(MultiPoint::toGeometry<mbgl::LinearRing<double>>(env, jHoleListsArray.Get(env, i)));
     }
 
     mbgl::FillAnnotation annotation { geometry };

platform/android/src/annotation/polygon.hpp

@@ -11,7 +11,7 @@ class Polygon : private MultiPoint {
 public:
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/annotations/Polygon"; };
 
-    static mbgl::FillAnnotation toAnnotation(jni::JNIEnv&, jni::Object<Polygon>);
+    static mbgl::FillAnnotation toAnnotation(jni::JNIEnv&, const jni::Object<Polygon>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/annotation/polyline.cpp

@@ -5,15 +5,15 @@
 namespace mbgl {
 namespace android {
 
-mbgl::LineAnnotation Polyline::toAnnotation(jni::JNIEnv& env, jni::Object<Polyline> polyline) {
-    static auto javaClass = jni::Class<Polyline>::Singleton(env);
+mbgl::LineAnnotation Polyline::toAnnotation(jni::JNIEnv& env, const jni::Object<Polyline>& polyline) {
+    static auto& javaClass = jni::Class<Polyline>::Singleton(env);
     static auto points = javaClass.GetField<jni::Object<java::util::List>>(env, "points");
     static auto alpha = javaClass.GetField<float>(env, "alpha");
     static auto color = javaClass.GetField<int>(env, "color");
     static auto width = javaClass.GetField<float>(env, "width");
 
     mbgl::LineAnnotation annotation {
-        MultiPoint::toGeometry<mbgl::LineString<double>>(env, *jni::SeizeLocal(env, polyline.Get(env, points)))
+        MultiPoint::toGeometry<mbgl::LineString<double>>(env, polyline.Get(env, points))
     };
 
     annotation.opacity = polyline.Get(env, alpha);

platform/android/src/annotation/polyline.hpp

@@ -11,7 +11,7 @@ class Polyline : private MultiPoint {
 public:
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/annotations/Polyline"; };
 
-    static mbgl::LineAnnotation toAnnotation(jni::JNIEnv&, jni::Object<Polyline>);
+    static mbgl::LineAnnotation toAnnotation(jni::JNIEnv&, const jni::Object<Polyline>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/asset_manager_file_source.cpp

@@ -38,10 +38,10 @@ private:
     AAssetManager* assetManager;
 };
 
-AssetManagerFileSource::AssetManagerFileSource(jni::JNIEnv& env, jni::Object<android::AssetManager> assetManager_)
-    : assetManager(assetManager_.NewGlobalRef(env)),
+AssetManagerFileSource::AssetManagerFileSource(jni::JNIEnv& env, const jni::Object<android::AssetManager>& assetManager_)
+    : assetManager(jni::NewGlobal(env, assetManager_)),
       impl(std::make_unique<util::Thread<Impl>>("AssetManagerFileSource",
-          AAssetManager_fromJava(&env, jni::Unwrap(**assetManager)))) {
+          AAssetManager_fromJava(&env, jni::Unwrap(assetManager.get())))) {
 }
 
 AssetManagerFileSource::~AssetManagerFileSource() = default;

platform/android/src/asset_manager_file_source.hpp

@@ -14,7 +14,7 @@ template <typename T> class Thread;
 
 class AssetManagerFileSource : public FileSource {
 public:
-    AssetManagerFileSource(jni::JNIEnv&, jni::Object<android::AssetManager>);
+    AssetManagerFileSource(jni::JNIEnv&, const jni::Object<android::AssetManager>&);
     ~AssetManagerFileSource() override;
 
     std::unique_ptr<AsyncRequest> request(const Resource&, Callback) override;

platform/android/src/bitmap.cpp

@@ -8,7 +8,7 @@ namespace android {
 
 class PixelGuard {
 public:
-    PixelGuard(jni::JNIEnv& env_, jni::Object<Bitmap> bitmap_) : env(env_), bitmap(bitmap_) {
+    PixelGuard(jni::JNIEnv& env_, const jni::Object<Bitmap>& bitmap_) : env(env_), bitmap(bitmap_) {
         const int result = AndroidBitmap_lockPixels(&env, jni::Unwrap(*bitmap),
                                                     reinterpret_cast<void**>(&address));
         if (result != ANDROID_BITMAP_RESULT_SUCCESS) {
@@ -29,25 +29,21 @@ public:
 
 private:
     jni::JNIEnv& env;
-    jni::Object<Bitmap> bitmap;
+    const jni::Object<Bitmap>& bitmap;
     uint8_t* address;
 };
 
-jni::Object<Bitmap::Config> Bitmap::Config::Create(jni::JNIEnv& env, Value value) {
-    static auto _class = jni::Class<Config>::Singleton(env);
+jni::Local<jni::Object<Bitmap::Config>> Bitmap::Config::Create(jni::JNIEnv& env, Value value) {
+    static auto& _class = jni::Class<Config>::Singleton(env);
     switch (value) {
     case ALPHA_8:
-        return _class.Get(env,
-                          jni::StaticField<Config, jni::Object<Config>>(env, _class, "ALPHA_8"));
+        return _class.Get(env, _class.GetStaticField<jni::Object<Config>>(env, "ALPHA_8"));
     case ARGB_4444:
-        return _class.Get(env,
-                          jni::StaticField<Config, jni::Object<Config>>(env, _class, "ARGB_4444"));
+        return _class.Get(env, _class.GetStaticField<jni::Object<Config>>(env, "ARGB_4444"));
     case ARGB_8888:
-        return _class.Get(env,
-                          jni::StaticField<Config, jni::Object<Config>>(env, _class, "ARGB_8888"));
+        return _class.Get(env, _class.GetStaticField<jni::Object<Config>>(env, "ARGB_8888"));
     case RGB_565:
-        return _class.Get(env,
-                          jni::StaticField<Config, jni::Object<Config>>(env, _class, "RGB_565"));
+        return _class.Get(env, _class.GetStaticField<jni::Object<Config>>(env, "RGB_565"));
     default:
         throw std::runtime_error("invalid enum value for Bitmap.Config");
     }
@@ -58,17 +54,41 @@ void Bitmap::registerNative(jni::JNIEnv& env) {
     jni::Class<Bitmap::Config>::Singleton(env);
 }
 
-jni::Object<Bitmap> Bitmap::CreateBitmap(jni::JNIEnv& env,
-                                         jni::jint width,
-                                         jni::jint height,
-                                         jni::Object<Config> config) {
-    static auto _class = jni::Class<Bitmap>::Singleton(env);
+jni::Local<jni::Object<Bitmap>> Bitmap::CreateBitmap(jni::JNIEnv& env,
+                                                     jni::jint width,
+                                                     jni::jint height,
+                                                     const jni::Object<Config>& config) {
+    static auto& _class = jni::Class<Bitmap>::Singleton(env);
     static auto method = _class.GetStaticMethod<jni::Object<Bitmap> (jni::jint, jni::jint, jni::Object<Config>)>(env, "createBitmap");
 
     return _class.Call(env, method, width, height, config);
 }
 
-jni::Object<Bitmap> Bitmap::CreateBitmap(jni::JNIEnv& env, const PremultipliedImage& image) {
+PremultipliedImage Bitmap::GetImage(jni::JNIEnv& env, const jni::Object<Bitmap>& bitmap) {
+    AndroidBitmapInfo info;
+    const int result = AndroidBitmap_getInfo(&env, jni::Unwrap(*bitmap), &info);
+    if (result != ANDROID_BITMAP_RESULT_SUCCESS) {
+        throw std::runtime_error("bitmap decoding: couldn't get bitmap info");
+    }
+    if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
+        return Bitmap::GetImage(env, Bitmap::Copy(env, bitmap));
+    }
+
+    PixelGuard guard(env, bitmap);
+
+    // Copy the Android Bitmap into the PremultipliedImage.
+    auto pixels =
+        std::make_unique<uint8_t[]>(info.width * info.height * PremultipliedImage::channels);
+    for (uint32_t y = 0; y < info.height; y++) {
+        auto begin = guard.get() + y * info.stride;
+        std::copy(begin, begin + info.width * PremultipliedImage::channels,
+            pixels.get() + y * info.width * PremultipliedImage::channels);
+    }
+
+    return { Size{ info.width, info.height }, std::move(pixels) };
+}
+
+jni::Local<jni::Object<Bitmap>> Bitmap::CreateBitmap(jni::JNIEnv& env, const PremultipliedImage& image) {
     auto bitmap = CreateBitmap(env, image.size.width, image.size.height, Config::ARGB_8888);
 
     AndroidBitmapInfo info;
@@ -93,32 +113,8 @@ jni::Object<Bitmap> Bitmap::CreateBitmap(jni::JNIEnv& env, const PremultipliedIm
     return bitmap;
 }
 
-PremultipliedImage Bitmap::GetImage(jni::JNIEnv& env, jni::Object<Bitmap> bitmap) {
-    AndroidBitmapInfo info;
-    const int result = AndroidBitmap_getInfo(&env, jni::Unwrap(*bitmap), &info);
-    if (result != ANDROID_BITMAP_RESULT_SUCCESS) {
-        throw std::runtime_error("bitmap decoding: couldn't get bitmap info");
-    }
-    if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
-        return Bitmap::GetImage(env, Bitmap::Copy(env, bitmap));
-    }
-
-    PixelGuard guard(env, bitmap);
-
-    // Copy the Android Bitmap into the PremultipliedImage.
-    auto pixels =
-        std::make_unique<uint8_t[]>(info.width * info.height * PremultipliedImage::channels);
-    for (uint32_t y = 0; y < info.height; y++) {
-        auto begin = guard.get() + y * info.stride;
-        std::copy(begin, begin + info.width * PremultipliedImage::channels,
-                  pixels.get() + y * info.width * PremultipliedImage::channels);
-    }
-
-    return { Size{ info.width, info.height }, std::move(pixels) };
-}
-
-jni::Object<Bitmap> Bitmap::Copy(jni::JNIEnv& env, jni::Object<Bitmap> bitmap) {
-    static auto klass = jni::Class<Bitmap>::Singleton(env);
+jni::Local<jni::Object<Bitmap>> Bitmap::Copy(jni::JNIEnv& env, const jni::Object<Bitmap>& bitmap) {
+    static auto& klass = jni::Class<Bitmap>::Singleton(env);
     static auto copy = klass.GetMethod<jni::Object<Bitmap> (jni::Object<Config>, jni::jboolean)>(env, "copy");
 
     return bitmap.Call(env, copy, Bitmap::Config::Create(env, Bitmap::Config::Value::ARGB_8888), jni::jni_false);

platform/android/src/bitmap.hpp

@@ -20,23 +20,23 @@ public:
             RGB_565,
         };
 
-        static jni::Object<Config> Create(jni::JNIEnv&, Value);
+        static jni::Local<jni::Object<Config>> Create(jni::JNIEnv&, Value);
     };
 
     static constexpr auto Name() { return "android/graphics/Bitmap"; };
     static void registerNative(jni::JNIEnv&);
 
-    static jni::Object<Bitmap>
-    CreateBitmap(jni::JNIEnv&, jni::jint width, jni::jint height, jni::Object<Config>);
+    static jni::Local<jni::Object<Bitmap>>
+    CreateBitmap(jni::JNIEnv&, jni::jint width, jni::jint height, const jni::Object<Config>&);
 
-    static jni::Object<Bitmap>
+    static jni::Local<jni::Object<Bitmap>>
     CreateBitmap(jni::JNIEnv& env, jni::jint width, jni::jint height, Config::Value config) {
         return CreateBitmap(env, width, height, Config::Create(env, config));
     }
 
-    static PremultipliedImage GetImage(jni::JNIEnv&, jni::Object<Bitmap>);
-    static jni::Object<Bitmap> CreateBitmap(jni::JNIEnv&, const PremultipliedImage&);
-    static jni::Object<Bitmap> Copy(jni::JNIEnv&, jni::Object<Bitmap>);
+    static PremultipliedImage GetImage(jni::JNIEnv&, const jni::Object<Bitmap>&);
+    static jni::Local<jni::Object<Bitmap>> CreateBitmap(jni::JNIEnv&, const PremultipliedImage&);
+    static jni::Local<jni::Object<Bitmap>> Copy(jni::JNIEnv&, const jni::Object<Bitmap>&);
 };
 
 } // namespace android

platform/android/src/bitmap_factory.cpp

@@ -7,11 +7,11 @@ void BitmapFactory::registerNative(jni::JNIEnv& env) {
     jni::Class<BitmapFactory>::Singleton(env);
 }
 
-jni::Object<Bitmap> BitmapFactory::DecodeByteArray(jni::JNIEnv& env,
-                                                   jni::Array<jni::jbyte> data,
-                                                   jni::jint offset,
-                                                   jni::jint length) {
-    static auto _class = jni::Class<BitmapFactory>::Singleton(env);
+jni::Local<jni::Object<Bitmap>> BitmapFactory::DecodeByteArray(jni::JNIEnv& env,
+                                                               jni::Array<jni::jbyte>& data,
+                                                               jni::jint offset,
+                                                               jni::jint length) {
+    static auto& _class = jni::Class<BitmapFactory>::Singleton(env);
 
     // Images are loaded with ARGB_8888 config, and premultiplied by default, which is exactly
     // what we want, so we're not providing a BitmapFactory.Options object.

platform/android/src/bitmap_factory.hpp

@@ -12,8 +12,8 @@ public:
     static constexpr auto Name() { return "android/graphics/BitmapFactory"; };
     static void registerNative(jni::JNIEnv&);
 
-    static jni::Object<Bitmap>
-    DecodeByteArray(jni::JNIEnv&, jni::Array<jni::jbyte> data, jni::jint offset, jni::jint length);
+    static jni::Local<jni::Object<Bitmap>>
+    DecodeByteArray(jni::JNIEnv&, jni::Array<jni::jbyte>& data, jni::jint offset, jni::jint length);
 };
 
 } // namespace android

platform/android/src/connectivity_listener.cpp

@@ -21,7 +21,7 @@ namespace android {
 
     void ConnectivityListener::registerNative(jni::JNIEnv& env) {
         // Lookup the class
-        static auto javaClass = jni::Class<ConnectivityListener>::Singleton(env);
+        static auto& javaClass = jni::Class<ConnectivityListener>::Singleton(env);
 
         #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 

platform/android/src/conversion/collection.cpp

@@ -5,23 +5,23 @@ namespace mbgl {
 namespace android {
 namespace conversion {
 
-std::vector<std::string> toVector(JNIEnv& env, jni::Array<jni::String> array) {
+std::vector<std::string> toVector(JNIEnv& env, const jni::Array<jni::String>& array) {
     std::size_t len = array.Length(env);
     std::vector<std::string> vector;
     vector.reserve(len);
 
     for (std::size_t i = 0; i < len; i++) {
-        vector.push_back(*convert<std::string>(env, *jni::SeizeLocal(env, array.Get(env, i))));
+        vector.push_back(jni::Make<std::string>(env, array.Get(env, i)));
     }
 
     return vector;
 }
 
-jni::Array<jni::String> toArray(JNIEnv& env, const std::vector<std::string>& vector) {
+jni::Local<jni::Array<jni::String>> toArray(JNIEnv& env, const std::vector<std::string>& vector) {
     auto result = jni::Array<jni::String>::New(env, vector.size());
 
     for (std::size_t i = 0; i < vector.size(); i++) {
-        result.Set(env, i, *jni::SeizeLocal(env, jni::Make<jni::String>(env, vector.at(i))));
+        result.Set(env, i, jni::Make<jni::String>(env, vector.at(i)));
     }
 
     return result;

platform/android/src/conversion/collection.hpp

@@ -10,8 +10,8 @@ namespace mbgl {
 namespace android {
 namespace conversion {
 
-std::vector<std::string> toVector(JNIEnv& env, jni::Array<jni::String> array);
-jni::Array<jni::String> toArray(JNIEnv& env, const std::vector<std::string>&);
+std::vector<std::string> toVector(JNIEnv& env, const jni::Array<jni::String>& array);
+jni::Local<jni::Array<jni::String>> toArray(JNIEnv& env, const std::vector<std::string>&);
 
 }
 }

platform/android/src/conversion/constant.cpp

@@ -1,4 +1,5 @@
 #include "constant.hpp"
+#include "collection.hpp"
 
 #include <sstream>
 
@@ -6,63 +7,46 @@ namespace mbgl {
 namespace android {
 namespace conversion {
 
-Result<jni::jobject*> Converter<jni::jobject*, bool>::operator()(jni::JNIEnv& env, const bool& value) const {
-    static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/lang/Boolean")).release();
-    static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "(Z)V");
-    return {&jni::NewObject(env, *javaClass, *constructor, (jboolean) value)};
+Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, bool>::operator()(jni::JNIEnv& env, const bool& value) const {
+    return jni::Box(env, value ? jni::jni_true : jni::jni_false);
 }
 
-Result<jni::jobject*> Converter<jni::jobject*, float>::operator()(jni::JNIEnv& env, const float& value) const {
-    static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/lang/Float")).release();
-    static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "(F)V");
-    return {&jni::NewObject(env, *javaClass, *constructor, (jfloat) value)};
+Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, float>::operator()(jni::JNIEnv& env, const float& value) const {
+    return jni::Box(env, value);
 }
 
-Result<jni::jobject*> Converter<jni::jobject*, double>::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)};
+Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, double>::operator()(jni::JNIEnv& env, const double& value) const {
+    return jni::Box(env, value);
 }
 
-Result<jni::jobject*> Converter<jni::jobject*, std::string>::operator()(jni::JNIEnv& env, const std::string& value) const {
-    return {jni::Make<jni::String>(env, value).Get()};
+Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::string>::operator()(jni::JNIEnv& env, const std::string& value) const {
+    return jni::Make<jni::String>(env, value);
 }
 
-Result<jni::jobject*> Converter<jni::jobject*, Color>::operator()(jni::JNIEnv& env, const Color& value) const {
+Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, Color>::operator()(jni::JNIEnv& env, const Color& value) const {
     std::stringstream sstream;
     sstream << "rgba(" << value.r << ", " << value.g << ", " << value.b << ", "  << value.a << ")";
-    std::string result = sstream.str();
-    return convert<jni::jobject*, std::string>(env, result);
+    return jni::Make<jni::String>(env, sstream.str());
 }
 
-Result<jni::jobject*> Converter<jni::jobject*, std::vector<std::string>>::operator()(jni::JNIEnv& env, const std::vector<std::string>& value) const {
-    static jni::jclass* stringCass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/lang/String")).release();
-    jni::jarray<jni::jobject>& jarray = jni::NewObjectArray(env, value.size(), *stringCass);
+Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vector<std::string>>::operator()(jni::JNIEnv& env, const std::vector<std::string>& value) const {
+    auto result = jni::Array<jni::String>::New(env, value.size());
 
-    for(size_t i = 0; i < value.size(); i = i + 1) {
-        Result<jni::jobject*> converted = convert<jni::jobject*, std::string>(env, value.at(i));
-        jni::SetObjectArrayElement(env, jarray, i, *converted);
+    for (std::size_t i = 0; i < value.size(); i++) {
+        result.Set(env, i, jni::Make<jni::String>(env, value.at(i)));
     }
 
-    return &jarray;
+    return result;
 }
 
-Result<jni::jobject*> Converter<jni::jobject*, std::vector<float>>::operator()(jni::JNIEnv& env, const std::vector<float>& value) const {
-    static jni::jclass* floatClass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/lang/Float")).release();
-    jni::jarray<jni::jobject>& jarray = jni::NewObjectArray(env, value.size(), *floatClass);
+Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vector<float>>::operator()(jni::JNIEnv& env, const std::vector<float>& value) const {
+    auto result = jni::Array<jni::Float>::New(env, value.size());
 
-    for(size_t i = 0; i < value.size(); i = i + 1) {
-        Result<jni::jobject*> converted = convert<jni::jobject*, float>(env, value.at(i));
-        jni::SetObjectArrayElement(env, jarray, i, *converted);
+    for (std::size_t i = 0; i < value.size(); i++) {
+        result.Set(env, i, jni::Box(env, value.at(i)));
     }
 
-    return &jarray;
-}
-
-// Java -> C++
-
-Result<std::string> Converter<std::string, jni::String>::operator()(jni::JNIEnv& env, const jni::String& value) const {
-    return { jni::Make<std::string>(env, value) };
+    return result;
 }
 
 } // namespace conversion

platform/android/src/conversion/constant.hpp

@@ -16,18 +16,18 @@ namespace android {
 namespace conversion {
 
 template <>
-struct Converter<jni::jobject*, bool> {
-    Result<jni::jobject*> operator()(jni::JNIEnv& env, const bool& value) const;
+struct Converter<jni::Local<jni::Object<>>, bool> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const bool& value) const;
 };
 
 template <>
-struct Converter<jni::jobject*, float> {
-    Result<jni::jobject*> operator()(jni::JNIEnv& env, const float& value) const;
+struct Converter<jni::Local<jni::Object<>>, float> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const float& value) const;
 };
 
 template <>
-struct Converter<jni::jobject*, double> {
-    Result<jni::jobject*> operator()(jni::JNIEnv& env, const double& value) const;
+struct Converter<jni::Local<jni::Object<>>, double> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const double& value) const;
 };
 
 /**
@@ -35,61 +35,52 @@ struct Converter<jni::jobject*, double> {
  * 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)};
+struct Converter<jni::Local<jni::Object<>>, T, typename std::enable_if<std::is_integral<T>::value>::type> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const T& value) const {
+        return jni::Box(env, jni::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;
+struct Converter<jni::Local<jni::Object<>>, std::string> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const std::string& value) const;
 };
 
 template <>
-struct Converter<jni::jobject*, Color> {
-    Result<jni::jobject*> operator()(jni::JNIEnv& env, const Color& value) const;
+struct Converter<jni::Local<jni::Object<>>, Color> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const Color& value) const;
 };
 
 template <std::size_t N>
-struct Converter<jni::jobject*, std::array<float, N>> {
-    Result<jni::jobject*> operator()(jni::JNIEnv& env, const std::array<float, N>& value) const {
+struct Converter<jni::Local<jni::Object<>>, std::array<float, N>> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const std::array<float, N>& value) const {
         std::vector<float> v;
         for (const float& id : value) {
             v.push_back(id);
         }
-        return convert<jni::jobject*, std::vector<float>>(env, v);
+        return convert<jni::Local<jni::Object<>>, std::vector<float>>(env, v);
     }
 };
 
 template <>
-struct Converter<jni::jobject*, std::vector<std::string>> {
-    Result<jni::jobject*> operator()(jni::JNIEnv& env, const std::vector<std::string>& value) const;
+struct Converter<jni::Local<jni::Object<>>, std::vector<std::string>> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const std::vector<std::string>& value) const;
 };
 
 template <>
-struct Converter<jni::jobject*, std::vector<float>> {
-    Result<jni::jobject*> operator()(jni::JNIEnv& env, const std::vector<float>& value) const;
+struct Converter<jni::Local<jni::Object<>>, std::vector<float>> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const std::vector<float>& value) const;
 };
 
 template <class T>
-struct Converter<jni::jobject*, T, typename std::enable_if_t<std::is_enum<T>::value>> {
-    Result<jni::jobject*> operator()(jni::JNIEnv& env, const T& value) const {
-        return convert<jni::jobject*, std::string>(env, Enum<T>::toString(value));
+struct Converter<jni::Local<jni::Object<>>, T, typename std::enable_if_t<std::is_enum<T>::value>> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const T& value) const {
+        return convert<jni::Local<jni::Object<>>, std::string>(env, Enum<T>::toString(value));
     }
 };
 
-// Java -> C++
-
-template <>
-struct Converter<std::string, jni::String> {
-    Result<std::string> operator()(jni::JNIEnv& env, const jni::String& value) const;
-};
-
 } // namespace conversion
-} // namespace style
+} // namespace android
 } // namespace mbgl

platform/android/src/file_source.cpp

@@ -1,4 +1,5 @@
 #include "file_source.hpp"
+#include "attach_env.hpp"
 
 #include <mbgl/actor/actor.hpp>
 #include <mbgl/actor/scheduler.hpp>
@@ -6,7 +7,6 @@
 #include <mbgl/util/logging.hpp>
 
 #include "asset_manager_file_source.hpp"
-#include "jni/generic_global_ref_deleter.hpp"
 
 namespace mbgl {
 namespace android {
@@ -14,9 +14,9 @@ namespace android {
 // FileSource //
 
 FileSource::FileSource(jni::JNIEnv& _env,
-                       jni::String accessToken,
-                       jni::String _cachePath,
-                       jni::Object<AssetManager> assetManager) {
+                       const jni::String& accessToken,
+                       const jni::String& _cachePath,
+                       const jni::Object<AssetManager>& assetManager) {
     // Create a core default file source
     fileSource = std::make_unique<mbgl::DefaultFileSource>(
         jni::Make<std::string>(_env, _cachePath) + "/mbgl-offline.db",
@@ -31,30 +31,31 @@ FileSource::FileSource(jni::JNIEnv& _env,
 FileSource::~FileSource() {
 }
 
-jni::String FileSource::getAccessToken(jni::JNIEnv& env) {
+jni::Local<jni::String> FileSource::getAccessToken(jni::JNIEnv& env) {
     return jni::Make<jni::String>(env, fileSource->getAccessToken());
 }
 
-void FileSource::setAccessToken(jni::JNIEnv& env, jni::String token) {
+void FileSource::setAccessToken(jni::JNIEnv& env, const jni::String& token) {
     fileSource->setAccessToken(jni::Make<std::string>(env, token));
 }
 
-void FileSource::setAPIBaseUrl(jni::JNIEnv& env, jni::String url) {
+void FileSource::setAPIBaseUrl(jni::JNIEnv& env, const jni::String& url) {
     fileSource->setAPIBaseURL(jni::Make<std::string>(env, url));
 }
 
-void FileSource::setResourceTransform(jni::JNIEnv& env, jni::Object<FileSource::ResourceTransformCallback> transformCallback) {
+void FileSource::setResourceTransform(jni::JNIEnv& env, const jni::Object<FileSource::ResourceTransformCallback>& transformCallback) {
     if (transformCallback) {
+        auto global = jni::NewGlobal<jni::EnvAttachingDeleter>(env, transformCallback);
         resourceTransform = std::make_unique<Actor<ResourceTransform>>(*Scheduler::GetCurrent(),
             // Capture the ResourceTransformCallback object as a managed global into
             // the lambda. It is released automatically when we're setting a new ResourceTransform in
             // a subsequent call.
             // Note: we're converting it to shared_ptr because this lambda is converted to a std::function,
             // which requires copyability of its captured variables.
-            [callback = std::shared_ptr<jni::jobject>(transformCallback.NewGlobalRef(env).release().Get(), GenericGlobalRefDeleter())]
+            [callback = std::make_shared<decltype(global)>(std::move(global))]
             (mbgl::Resource::Kind kind, const std::string&& url_) {
                 android::UniqueEnv _env = android::AttachEnv();
-                return FileSource::ResourceTransformCallback::onURL(*_env, jni::Object<FileSource::ResourceTransformCallback>(*callback), int(kind), url_);
+                return FileSource::ResourceTransformCallback::onURL(*_env, *callback, int(kind), url_);
             });
         fileSource->setResourceTransform(resourceTransform->self());
     } else {
@@ -92,13 +93,13 @@ jni::jboolean FileSource::isResumed(jni::JNIEnv&) {
     return (jboolean) false;
 }
 
-FileSource* FileSource::getNativePeer(jni::JNIEnv& env, jni::Object<FileSource> jFileSource) {
-    static auto javaClass = jni::Class<FileSource>::Singleton(env);
+FileSource* FileSource::getNativePeer(jni::JNIEnv& env, const jni::Object<FileSource>& jFileSource) {
+    static auto& javaClass = jni::Class<FileSource>::Singleton(env);
     static auto field = javaClass.GetField<jlong>(env, "nativePtr");
     return reinterpret_cast<FileSource *>(jFileSource.Get(env, field));
 }
 
-mbgl::DefaultFileSource& FileSource::getDefaultFileSource(jni::JNIEnv& env, jni::Object<FileSource> jFileSource) {
+mbgl::DefaultFileSource& FileSource::getDefaultFileSource(jni::JNIEnv& env, const jni::Object<FileSource>& jFileSource) {
     FileSource* fileSource = FileSource::getNativePeer(env, jFileSource);
     assert(fileSource != nullptr);
     return *fileSource->fileSource;
@@ -110,14 +111,14 @@ void FileSource::registerNative(jni::JNIEnv& env) {
     // https://developer.android.com/training/articles/perf-jni#faq_FindClass
     jni::Class<ResourceTransformCallback>::Singleton(env);
 
-    static auto javaClass = jni::Class<FileSource>::Singleton(env);
+    static auto& javaClass = jni::Class<FileSource>::Singleton(env);
 
     #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
     // Register the peer
     jni::RegisterNativePeer<FileSource>(
         env, javaClass, "nativePtr",
-        std::make_unique<FileSource, JNIEnv&, jni::String, jni::String, jni::Object<AssetManager>>,
+        jni::MakePeer<FileSource, const jni::String&, const jni::String&, const jni::Object<AssetManager>&>,
         "initialize",
         "finalize",
         METHOD(&FileSource::getAccessToken, "getAccessToken"),
@@ -133,13 +134,13 @@ void FileSource::registerNative(jni::JNIEnv& env) {
 
 // FileSource::ResourceTransformCallback //
 
-std::string FileSource::ResourceTransformCallback::onURL(jni::JNIEnv& env, jni::Object<FileSource::ResourceTransformCallback> callback, int kind, std::string url_) {
-    static auto javaClass = jni::Class<FileSource::ResourceTransformCallback>::Singleton(env);
+std::string FileSource::ResourceTransformCallback::onURL(jni::JNIEnv& env, const jni::Object<FileSource::ResourceTransformCallback>& callback, int kind, std::string url_) {
+    static auto& javaClass = jni::Class<FileSource::ResourceTransformCallback>::Singleton(env);
     static auto method = javaClass.GetMethod<jni::String (jni::jint, jni::String)>(env, "onURL");
 
     return jni::Make<std::string>(env,
-        *jni::SeizeLocal(env, callback.Call(env, method, kind,
-            *jni::SeizeLocal(env, jni::Make<jni::String>(env, url_)))));
+        callback.Call(env, method, kind,
+            jni::Make<jni::String>(env, url_)));
 }
 
 } // namespace android

platform/android/src/file_source.hpp

@@ -24,20 +24,20 @@ public:
     struct ResourceTransformCallback {
         static constexpr auto Name() { return "com/mapbox/mapboxsdk/storage/FileSource$ResourceTransformCallback"; }
 
-        static std::string onURL(jni::JNIEnv&, jni::Object<FileSource::ResourceTransformCallback>, int, std::string);
+        static std::string onURL(jni::JNIEnv&, const jni::Object<FileSource::ResourceTransformCallback>&, int, std::string);
     };
 
-    FileSource(jni::JNIEnv&, jni::String, jni::String, jni::Object<AssetManager>);
+    FileSource(jni::JNIEnv&, const jni::String&, const jni::String&, const jni::Object<AssetManager>&);
 
     ~FileSource();
 
-    jni::String getAccessToken(jni::JNIEnv&);
+    jni::Local<jni::String> getAccessToken(jni::JNIEnv&);
 
-    void setAccessToken(jni::JNIEnv&, jni::String);
+    void setAccessToken(jni::JNIEnv&, const jni::String&);
 
-    void setAPIBaseUrl(jni::JNIEnv&, jni::String);
+    void setAPIBaseUrl(jni::JNIEnv&, const jni::String&);
 
-    void setResourceTransform(jni::JNIEnv&, jni::Object<FileSource::ResourceTransformCallback>);
+    void setResourceTransform(jni::JNIEnv&, const jni::Object<FileSource::ResourceTransformCallback>&);
 
     void resume(jni::JNIEnv&);
 
@@ -45,9 +45,9 @@ public:
 
     jni::jboolean isResumed(jni::JNIEnv&);
 
-    static FileSource* getNativePeer(jni::JNIEnv&, jni::Object<FileSource>);
+    static FileSource* getNativePeer(jni::JNIEnv&, const jni::Object<FileSource>&);
 
-    static mbgl::DefaultFileSource& getDefaultFileSource(jni::JNIEnv&, jni::Object<FileSource>);
+    static mbgl::DefaultFileSource& getDefaultFileSource(jni::JNIEnv&, const jni::Object<FileSource>&);
 
     static void registerNative(jni::JNIEnv&);
 

platform/android/src/geojson/feature.cpp

@@ -8,18 +8,18 @@ namespace geojson {
 
 using namespace gson;
 
-mbgl::Feature Feature::convert(jni::JNIEnv& env, jni::Object<Feature> jFeature) {
-    static auto javaClass = jni::Class<Feature>::Singleton(env);
+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 = jni::SeizeLocal(env, jFeature.Call(env, id));
+    auto jId = jFeature.Call(env, id);
 
     return mbgl::Feature {
-        Geometry::convert(env, *jni::SeizeLocal(env, jFeature.Call(env, geometry))),
-        JsonObject::convert(env, *jni::SeizeLocal(env, jFeature.Call(env, properties))),
-        jId ? std::experimental::optional<mapbox::geometry::identifier>(jni::Make<std::string>(env, *jId))
+        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
     };
 }
@@ -43,21 +43,21 @@ public:
     }
 };
 
-jni::Object<Feature> convertFeature(jni::JNIEnv& env, const mbgl::Feature& value) {
-    static auto javaClass = jni::Class<Feature>::Singleton(env);
+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");
 
     return javaClass.Call(env, method,
-        *jni::SeizeLocal(env, Geometry::New(env, value.geometry)),
-        *jni::SeizeLocal(env, JsonObject::New(env, value.properties)),
-        *jni::SeizeLocal(env, jni::Make<jni::String>(env, value.id ? value.id.value().match(FeatureIdVisitor()) : "")));
+        Geometry::New(env, value.geometry),
+        JsonObject::New(env, value.properties),
+        jni::Make<jni::String>(env, value.id ? value.id.value().match(FeatureIdVisitor()) : ""));
 }
 
-jni::Array<jni::Object<Feature>> Feature::convert(jni::JNIEnv& env, const std::vector<mbgl::Feature>& value) {
+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, *jni::SeizeLocal(env, convertFeature(env, value.at(i))));
+        features.Set(env, i, convertFeature(env, value.at(i)));
     }
 
     return features;

platform/android/src/geojson/feature.hpp

@@ -8,12 +8,12 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-class Feature : public jni::ObjectTag {
+class Feature {
 public:
     static constexpr auto Name() { return "com/mapbox/geojson/Feature"; };
 
-    static mbgl::Feature convert(jni::JNIEnv&, jni::Object<Feature>);
-    static jni::Array<jni::Object<Feature>> convert(jni::JNIEnv&, const std::vector<mbgl::Feature>&);
+    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&);
 };

platform/android/src/geojson/feature_collection.cpp

@@ -6,24 +6,24 @@ 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) {
-        auto jFeatureList = jni::SeizeLocal(env, FeatureCollection::features(env, jCollection));
-        auto jFeatures = jni::SeizeLocal(env, java::util::List::toArray<Feature>(env, *jFeatureList));
-        auto size = size_t(jFeatures->Length(env));
+        auto jFeatureList = FeatureCollection::features(env, jCollection);
+        auto jFeatures = java::util::List::toArray<Feature>(env, jFeatureList);
+        auto size = size_t(jFeatures.Length(env));
         collection.reserve(size);
 
         for (size_t i = 0; i < size; i++) {
-            collection.push_back(Feature::convert(env, *jni::SeizeLocal(env, jFeatures->Get(env, i))));
+            collection.push_back(Feature::convert(env, jFeatures.Get(env, i)));
         }
     }
     return collection;
 }
 
-jni::Object<java::util::List> FeatureCollection::features(jni::JNIEnv& env, jni::Object<FeatureCollection> jCollection) {
-    static auto javaClass = jni::Class<FeatureCollection>::Singleton(env);
+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);
 }

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,13 +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::Local<jni::Object<java::util::List>> features(jni::JNIEnv&, const jni::Object<FeatureCollection>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/geojson/geometry.cpp

@@ -22,65 +22,65 @@ public:
 
     jni::JNIEnv& env;
 
-    jni::Object<Geometry> operator()(const mbgl::Point<double> &geometry) const {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 javaClass = jni::Class<Geometry>::Singleton(env);
+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, *jni::SeizeLocal(env, jGeometry.Call(env, method)));
+    return jni::Make<std::string>(env, jGeometry.Call(env, method));
 }
 
 void Geometry::registerNative(jni::JNIEnv &env) {

platform/android/src/geojson/geometry.hpp

@@ -14,11 +14,11 @@ 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 std::string getType(jni::JNIEnv&, const jni::Object<Geometry>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/geojson/geometry_collection.cpp

@@ -5,36 +5,34 @@ 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::SeizeLocal(env, jni::Array<jni::Object<Geometry>>::New(env, collection.size()));
+    auto jarray = jni::Array<jni::Object<Geometry>>::New(env, collection.size());
 
     for (size_t i = 0; i < collection.size(); i++) {
-        jarray->Set(env, i, *jni::SeizeLocal(env, Geometry::New(env, collection.at(i))));
+        jarray.Set(env, i, Geometry::New(env, collection.at(i)));
     }
 
     // create the GeometryCollection
-    static auto javaClass = jni::Class<GeometryCollection>::Singleton(env);
+    static auto& javaClass = jni::Class<GeometryCollection>::Singleton(env);
     static auto method = javaClass.GetStaticMethod<jni::Object<GeometryCollection> (jni::Object<java::util::List>)>(env, "fromGeometries");
-    return javaClass.Call(env, method, *jni::SeizeLocal(env, java::util::Arrays::asList(env, *jarray)));
+    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& javaClass = jni::Class<GeometryCollection>::Singleton(env);
     static auto getGeometries = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "geometries");
 
     // Turn into array
-    auto jarray = jni::SeizeLocal(env,
-        java::util::List::toArray<Geometry>(env,
-            *jni::SeizeLocal(env, jCollection.Call(env, getGeometries))));
+    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);
+    auto size = jarray.Length(env);
     for (jni::jsize i = 0; i < size; i++) {
-        collection.push_back(Geometry::convert(env, *jni::SeizeLocal(env, jarray->Get(env, i))));
+        collection.push_back(Geometry::convert(env, jarray.Get(env, i)));
     }
 
     return collection;

platform/android/src/geojson/geometry_collection.hpp

@@ -8,15 +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 jni::Local<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 mapbox::geometry::geometry_collection<double> convert(jni::JNIEnv&, const jni::Object<GeometryCollection>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/geojson/line_string.cpp

@@ -7,42 +7,41 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-jni::Object<LineString> LineString::New(jni::JNIEnv& env, const mbgl::LineString<double>& lineString) {
-    static auto javaClass = jni::Class<LineString>::Singleton(env);
+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");
 
-    return javaClass.Call(env, method,
-        *jni::SeizeLocal(env, asPointsList(env, lineString)));
+    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) {
-        lineString = LineString::convert(env, *jni::SeizeLocal(env, LineString::coordinates(env, jLineString)));
+        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) {
-        auto jPointArray = jni::SeizeLocal(env, java::util::List::toArray<Point>(env, jPointList));
-        auto size = jPointArray->Length(env);
+        auto jPointArray = java::util::List::toArray<Point>(env, jPointList);
+        auto size = jPointArray.Length(env);
         lineString.reserve(size);
 
         for (std::size_t i = 0; i < size; i++) {
-            lineString.push_back(Point::convert(env, *jni::SeizeLocal(env, jPointArray->Get(env, i))));
+            lineString.push_back(Point::convert(env, jPointArray.Get(env, i)));
         }
     }
 
     return lineString;
 }
 
-jni::Object<java::util::List> LineString::coordinates(jni::JNIEnv &env, jni::Object<LineString> jLineString) {
-    static auto javaClass = jni::Class<LineString>::Singleton(env);
+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);
 }

platform/android/src/geojson/line_string.hpp

@@ -14,19 +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 jni::Local<jni::Object<LineString>> New(jni::JNIEnv&, const mbgl::LineString<double>&);
 
-    static mapbox::geojson::line_string convert(jni::JNIEnv&, jni::Object<LineString>);
+    static mapbox::geojson::line_string convert(jni::JNIEnv&, const jni::Object<LineString>&);
 
-    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<java::util::List/*<Point>*/>&);
 
-    static jni::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<LineString>);
+    static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv&, const jni::Object<LineString>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/geojson/multi_line_string.cpp

@@ -7,44 +7,42 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-jni::Object<MultiLineString> MultiLineString::New(jni::JNIEnv& env, const mbgl::MultiLineString<double>& multiLineString) {
-    static auto javaClass = jni::Class<MultiLineString>::Singleton(env);
+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");
 
-    return javaClass.Call(env, method,
-        *jni::SeizeLocal(env, asPointsListsList(env, multiLineString)));
+    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) {
-        multiLineString = MultiLineString::convert(env,
-            *jni::SeizeLocal(env, MultiLineString::coordinates(env, jMultiLineString)));
+        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) {
-        auto jPositionListsArray = jni::SeizeLocal(env, java::util::List::toArray<java::util::List>(env, jPointListsList));
+        auto jPositionListsArray = java::util::List::toArray<java::util::List>(env, jPointListsList);
 
-        auto size = jPositionListsArray->Length(env);
+        auto size = jPositionListsArray.Length(env);
         multiLineString.reserve(size);
 
         for (std::size_t i = 0; i < size; i++) {
-            multiLineString.push_back(LineString::convert(env, *jni::SeizeLocal(env, jPositionListsArray->Get(env, i))));
+            multiLineString.push_back(LineString::convert(env, jPositionListsArray.Get(env, i)));
         }
     }
 
     return multiLineString;
 }
 
-jni::Object<java::util::List> MultiLineString::coordinates(jni::JNIEnv &env, jni::Object<MultiLineString> jLineString) {
-    static auto javaClass = jni::Class<MultiLineString>::Singleton(env);
+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);
 }

platform/android/src/geojson/multi_line_string.hpp

@@ -12,19 +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 jni::Local<jni::Object<MultiLineString>> New(jni::JNIEnv&, const mbgl::MultiLineString<double>&);
 
-    static mapbox::geojson::multi_line_string convert(jni::JNIEnv&, jni::Object<MultiLineString>);
+    static mapbox::geojson::multi_line_string convert(jni::JNIEnv&, const jni::Object<MultiLineString>&);
 
-    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<java::util::List/*<java::util::List<Point>>*/>&);
 
-    static jni::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<MultiLineString>);
+    static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv&, const jni::Object<MultiLineString>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/geojson/multi_point.cpp

@@ -8,26 +8,26 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-jni::Object<MultiPoint> MultiPoint::New(JNIEnv& env, const mbgl::MultiPoint<double>& multiPoint) {
-    static auto javaClass = jni::Class<MultiPoint>::Singleton(env);
+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");
 
-    return javaClass.Call(env, method, *jni::SeizeLocal(env, asPointsList(env, multiPoint)));
+    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) {
         multiPoint = convertExplicit<mapbox::geojson::multi_point>(
-            LineString::convert(env, *jni::SeizeLocal(env, MultiPoint::coordinates(env, jMultiPoint))));
+            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 javaClass = jni::Class<MultiPoint>::Singleton(env);
+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);
 }

platform/android/src/geojson/multi_point.hpp

@@ -13,17 +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 jni::Local<jni::Object<MultiPoint>> New(jni::JNIEnv&, const mbgl::MultiPoint<double>&);
 
-    static mapbox::geojson::multi_point convert(jni::JNIEnv&, jni::Object<MultiPoint>);
+    static mapbox::geojson::multi_point convert(jni::JNIEnv&, const jni::Object<MultiPoint>&);
 
-    static jni::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<MultiPoint>);
+    static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv&, const jni::Object<MultiPoint>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/geojson/multi_polygon.cpp

@@ -7,41 +7,39 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-jni::Object<MultiPolygon> MultiPolygon::New(JNIEnv& env, const mbgl::MultiPolygon<double>& multiPolygon) {
-    static auto javaClass = jni::Class<MultiPolygon>::Singleton(env);
+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::SeizeLocal(env,
-        jni::Array<jni::Object<java::util::List>>::New(env, multiPolygon.size()));
+    auto jarray = jni::Array<jni::Object<java::util::List>>::New(env, multiPolygon.size());
 
     for (size_t i = 0; i < multiPolygon.size(); i++) {
-        jarray->Set(env, i, *jni::SeizeLocal(env, asPointsListsList(env, multiPolygon.at(i))));
+        jarray.Set(env, i, asPointsListsList(env, multiPolygon.at(i)));
     }
 
-    return javaClass.Call(env, method,
-        *jni::SeizeLocal(env, java::util::Arrays::asList(env, *jarray)));
+    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) {
-        auto jPointListsListList = jni::SeizeLocal(env, MultiPolygon::coordinates(env, jMultiPolygon));
-        auto jPointListsListArray = jni::SeizeLocal(env, java::util::List::toArray<java::util::List>(env, *jPointListsListList));
+        auto jPointListsListList = MultiPolygon::coordinates(env, jMultiPolygon);
+        auto jPointListsListArray = java::util::List::toArray<java::util::List>(env, jPointListsListList);
 
-        auto size = jPointListsListArray->Length(env);
+        auto size = jPointListsListArray.Length(env);
         multiPolygon.reserve(size);
 
         for (size_t i = 0; i < size; i++) {
-            multiPolygon.push_back(Polygon::convert(env, *jni::SeizeLocal(env, jPointListsListArray->Get(env, i))));
+            multiPolygon.push_back(Polygon::convert(env, jPointListsListArray.Get(env, i)));
         }
     }
 
     return multiPolygon;
 }
 
-jni::Object<java::util::List> MultiPolygon::coordinates(jni::JNIEnv &env, jni::Object<MultiPolygon> jPolygon) {
-    static auto javaClass = jni::Class<MultiPolygon>::Singleton(env);
+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);
 }

platform/android/src/geojson/multi_polygon.hpp

@@ -12,17 +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 jni::Local<jni::Object<MultiPolygon>> New(jni::JNIEnv&, const mbgl::MultiPolygon<double>&);
 
-    static mapbox::geojson::multi_polygon convert(jni::JNIEnv&, jni::Object<MultiPolygon>);
+    static mapbox::geojson::multi_polygon convert(jni::JNIEnv&, const jni::Object<MultiPolygon>&);
 
-    static jni::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<MultiPolygon>);
+    static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv&, const jni::Object<MultiPolygon>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/geojson/point.cpp

@@ -4,14 +4,14 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-jni::Object<Point> Point::New(jni::JNIEnv& env, const mbgl::Point<double>& point) {
-    static auto javaClass = jni::Class<Point>::Singleton(env);
+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);
 }
 
-mbgl::Point<double> Point::convert(jni::JNIEnv &env, jni::Object<Point> jPoint) {
-    static auto javaClass = jni::Class<Point>::Singleton(env);
+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");
 

platform/android/src/geojson/point.hpp

@@ -10,13 +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 mbgl::Point<double> convert(jni::JNIEnv&, jni::Object<Point>);
+    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&);
 };

platform/android/src/geojson/polygon.cpp

@@ -8,24 +8,24 @@ namespace mbgl {
 namespace android {
 namespace geojson {
 
-jni::Object<Polygon> Polygon::New(jni::JNIEnv& env, const mbgl::Polygon<double>& polygon) {
-    static auto javaClass = jni::Class<Polygon>::Singleton(env);
+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");
 
-    return javaClass.Call(env, method, *jni::SeizeLocal(env, asPointsListsList(env, polygon)));
+    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) {
-        polygon = Polygon::convert(env, *jni::SeizeLocal(env, Polygon::coordinates(env, jPolygon)));
+        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) {
@@ -40,8 +40,8 @@ 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 javaClass = jni::Class<Polygon>::Singleton(env);
+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);
 }

platform/android/src/geojson/polygon.hpp

@@ -13,19 +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 jni::Local<jni::Object<Polygon>> New(jni::JNIEnv&, const mbgl::Polygon<double>&);
 
-    static mapbox::geojson::polygon convert(jni::JNIEnv &, jni::Object<Polygon>);
+    static mapbox::geojson::polygon convert(jni::JNIEnv &, const jni::Object<Polygon>&);
 
-    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<java::util::List/*<java::util::List<Point>>*/>&);
 
-    static jni::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<Polygon>);
+    static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv&, const jni::Object<Polygon>&);
 
     static void registerNative(jni::JNIEnv &);
 };

platform/android/src/geojson/util.hpp

@@ -23,28 +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::SeizeLocal(env, jni::Array<jni::Object<Point>>::New(env, pointsList.size()));
+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++) {
-        jarray->Set(env, i, *jni::SeizeLocal(env, Point::New(env, pointsList.at(i))));
+        jarray.Set(env, i, Point::New(env, pointsList.at(i)));
     }
 
-    return java::util::Arrays::asList(env, *jarray);
+    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::SeizeLocal(env, jni::Array<jni::Object<java::util::List>>::New(env, value.size()));
+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++) {
-        jarray->Set(env, i, *jni::SeizeLocal(env, asPointsList(env, value[i])));
+        jarray.Set(env, i, asPointsList(env, value[i]));
     }
 
-    return java::util::Arrays::asList(env, *jarray);
+    return java::util::Arrays::asList(env, jarray);
 }
 
 } // namespace geojson

platform/android/src/geometry/lat_lng.cpp

@@ -3,20 +3,20 @@
 namespace mbgl {
 namespace android {
 
-jni::Object<LatLng> LatLng::New(jni::JNIEnv& env, const mbgl::LatLng& latLng) {
-    static auto javaClass = jni::Class<LatLng>::Singleton(env);
+jni::Local<jni::Object<LatLng>> LatLng::New(jni::JNIEnv& env, const mbgl::LatLng& latLng) {
+    static auto& javaClass = jni::Class<LatLng>::Singleton(env);
     static auto constructor = javaClass.GetConstructor<double, double>(env);
     return javaClass.New(env, constructor, latLng.latitude(), latLng.longitude());
 }
 
-mbgl::Point<double> LatLng::getGeometry(jni::JNIEnv& env, jni::Object<LatLng> latLng) {
-    static auto javaClass = jni::Class<LatLng>::Singleton(env);
+mbgl::Point<double> LatLng::getGeometry(jni::JNIEnv& env, const jni::Object<LatLng>& latLng) {
+    static auto& javaClass = jni::Class<LatLng>::Singleton(env);
     static auto latitudeField = javaClass.GetField<jni::jdouble>(env, "latitude");
     static auto longitudeField = javaClass.GetField<jni::jdouble>(env, "longitude");
     return mbgl::Point<double>(latLng.Get(env, longitudeField), latLng.Get(env, latitudeField));
 }
 
-mbgl::LatLng LatLng::getLatLng(jni::JNIEnv& env, jni::Object<LatLng> latLng) {
+mbgl::LatLng LatLng::getLatLng(jni::JNIEnv& env, const jni::Object<LatLng>& latLng) {
     auto point = LatLng::getGeometry(env, latLng);
     return mbgl::LatLng(point.y, point.x);
 }

platform/android/src/geometry/lat_lng.hpp

@@ -14,11 +14,11 @@ public:
 
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/geometry/LatLng"; };
 
-    static jni::Object<LatLng> New(jni::JNIEnv&, const mbgl::LatLng&);
+    static jni::Local<jni::Object<LatLng>> New(jni::JNIEnv&, const mbgl::LatLng&);
 
-    static mbgl::Point<double> getGeometry(jni::JNIEnv&, jni::Object<LatLng>);
+    static mbgl::Point<double> getGeometry(jni::JNIEnv&, const jni::Object<LatLng>&);
 
-    static mbgl::LatLng getLatLng(jni::JNIEnv&, jni::Object<LatLng>);
+    static mbgl::LatLng getLatLng(jni::JNIEnv&, const jni::Object<LatLng>&);
 
 
     static void registerNative(jni::JNIEnv&);

platform/android/src/geometry/lat_lng_bounds.cpp

@@ -3,14 +3,14 @@
 namespace mbgl {
 namespace android {
 
-jni::Object<LatLngBounds> LatLngBounds::New(jni::JNIEnv& env, mbgl::LatLngBounds bounds) {
-    static auto javaClass = jni::Class<LatLngBounds>::Singleton(env);
+jni::Local<jni::Object<LatLngBounds>> LatLngBounds::New(jni::JNIEnv& env, mbgl::LatLngBounds bounds) {
+    static auto& javaClass = jni::Class<LatLngBounds>::Singleton(env);
     static auto constructor = javaClass.GetConstructor<double, double, double, double>(env);
     return javaClass.New(env, constructor, bounds.north(), bounds.east(), bounds.south(), bounds.west());
 }
 
-mbgl::LatLngBounds LatLngBounds::getLatLngBounds(jni::JNIEnv& env, jni::Object<LatLngBounds> bounds) {
-    static auto javaClass = jni::Class<LatLngBounds>::Singleton(env);
+mbgl::LatLngBounds LatLngBounds::getLatLngBounds(jni::JNIEnv& env, const jni::Object<LatLngBounds>& bounds) {
+    static auto& javaClass = jni::Class<LatLngBounds>::Singleton(env);
     static auto swLatField = javaClass.GetField<jni::jdouble>(env, "latitudeSouth");
     static auto swLonField = javaClass.GetField<jni::jdouble>(env, "longitudeWest");
     static auto neLatField = javaClass.GetField<jni::jdouble>(env, "latitudeNorth");

platform/android/src/geometry/lat_lng_bounds.hpp

@@ -14,9 +14,9 @@ public:
 
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/geometry/LatLngBounds"; };
 
-    static jni::Object<LatLngBounds> New(jni::JNIEnv&, mbgl::LatLngBounds);
+    static jni::Local<jni::Object<LatLngBounds>> New(jni::JNIEnv&, mbgl::LatLngBounds);
 
-    static mbgl::LatLngBounds getLatLngBounds(jni::JNIEnv&, jni::Object<LatLngBounds>);
+    static mbgl::LatLngBounds getLatLngBounds(jni::JNIEnv&, const jni::Object<LatLngBounds>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/geometry/lat_lng_quad.cpp

@@ -4,8 +4,8 @@
 namespace mbgl {
 namespace android {
 
-jni::Object<LatLngQuad> LatLngQuad::New(jni::JNIEnv& env, std::array<mbgl::LatLng, 4> coordinates) {
-    static auto javaClass = jni::Class<LatLngQuad>::Singleton(env);
+jni::Local<jni::Object<LatLngQuad>> LatLngQuad::New(jni::JNIEnv& env, std::array<mbgl::LatLng, 4> coordinates) {
+    static auto& javaClass = jni::Class<LatLngQuad>::Singleton(env);
     static auto quadConstructor = javaClass.GetConstructor<jni::Object<LatLng>, jni::Object<LatLng>, jni::Object<LatLng>, jni::Object<LatLng>>(env);
     return javaClass.New(env, quadConstructor,
         LatLng::New(env, coordinates[0]),
@@ -14,8 +14,8 @@ jni::Object<LatLngQuad> LatLngQuad::New(jni::JNIEnv& env, std::array<mbgl::LatLn
         LatLng::New(env, coordinates[3]));
 }
 
-std::array<mbgl::LatLng, 4> LatLngQuad::getLatLngArray(jni::JNIEnv& env, jni::Object<LatLngQuad> quad) {
-    static auto javaClass = jni::Class<LatLngQuad>::Singleton(env);
+std::array<mbgl::LatLng, 4> LatLngQuad::getLatLngArray(jni::JNIEnv& env, const jni::Object<LatLngQuad>& quad) {
+    static auto& javaClass = jni::Class<LatLngQuad>::Singleton(env);
     static auto topLeftField = javaClass.GetField <jni::Object<LatLng>>(env, "topLeft");
     static auto topRightField = javaClass.GetField <jni::Object<LatLng>>(env, "topRight");
     static auto bottomRightField = javaClass.GetField <jni::Object<LatLng>>(env, "bottomRight");

platform/android/src/geometry/lat_lng_quad.hpp

@@ -15,9 +15,9 @@ public:
 
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/geometry/LatLngQuad"; };
 
-    static jni::Object<LatLngQuad> New(jni::JNIEnv&, std::array<mbgl::LatLng, 4>);
+    static jni::Local<jni::Object<LatLngQuad>> New(jni::JNIEnv&, std::array<mbgl::LatLng, 4>);
 
-    static std::array<mbgl::LatLng, 4> getLatLngArray(jni::JNIEnv&, jni::Object<LatLngQuad>);
+    static std::array<mbgl::LatLng, 4> getLatLngArray(jni::JNIEnv&, const jni::Object<LatLngQuad>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/geometry/projected_meters.cpp

@@ -3,8 +3,8 @@
 namespace mbgl {
 namespace android {
 
-jni::Object<ProjectedMeters> ProjectedMeters::New(jni::JNIEnv& env, double northing, double easting) {
-    static auto javaClass = jni::Class<ProjectedMeters>::Singleton(env);
+jni::Local<jni::Object<ProjectedMeters>> ProjectedMeters::New(jni::JNIEnv& env, double northing, double easting) {
+    static auto& javaClass = jni::Class<ProjectedMeters>::Singleton(env);
     static auto constructor = javaClass.GetConstructor<double, double>(env);
     return javaClass.New(env, constructor, northing, easting);
 }

platform/android/src/geometry/projected_meters.hpp

@@ -12,7 +12,7 @@ class ProjectedMeters : private mbgl::util::noncopyable {
 public:
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/geometry/ProjectedMeters"; };
 
-    static jni::Object<ProjectedMeters> New(jni::JNIEnv&, double, double);
+    static jni::Local<jni::Object<ProjectedMeters>> New(jni::JNIEnv&, double, double);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/graphics/pointf.cpp

@@ -4,14 +4,14 @@
 namespace mbgl {
 namespace android {
 
-jni::Object<PointF> PointF::New(jni::JNIEnv& env, float x, float y) {
-    static auto javaClass = jni::Class<PointF>::Singleton(env);
+jni::Local<jni::Object<PointF>> PointF::New(jni::JNIEnv& env, float x, float y) {
+    static auto& javaClass = jni::Class<PointF>::Singleton(env);
     static auto constructor = javaClass.GetConstructor<float, float>(env);
     return javaClass.New(env, constructor, x, y);
 }
 
-mbgl::ScreenCoordinate PointF::getScreenCoordinate(jni::JNIEnv& env, jni::Object<PointF> point) {
-    static auto javaClass = jni::Class<PointF>::Singleton(env);
+mbgl::ScreenCoordinate PointF::getScreenCoordinate(jni::JNIEnv& env, const jni::Object<PointF>& point) {
+    static auto& javaClass = jni::Class<PointF>::Singleton(env);
     static auto xField = javaClass.GetField<jni::jfloat>(env, "x");
     static auto yField = javaClass.GetField<jni::jfloat>(env, "y");
     return mbgl::ScreenCoordinate{point.Get(env, xField), point.Get(env, yField)};

platform/android/src/graphics/pointf.hpp

@@ -12,9 +12,9 @@ public:
 
     static constexpr auto Name() { return "android/graphics/PointF"; };
 
-    static jni::Object<PointF> New(jni::JNIEnv&, float, float);
+    static jni::Local<jni::Object<PointF>> New(jni::JNIEnv&, float, float);
 
-    static mbgl::ScreenCoordinate getScreenCoordinate(jni::JNIEnv&, jni::Object<PointF>);
+    static mbgl::ScreenCoordinate getScreenCoordinate(jni::JNIEnv&, const jni::Object<PointF>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/graphics/rectf.cpp

@@ -3,26 +3,26 @@
 namespace mbgl {
 namespace android {
 
-float RectF::getLeft(jni::JNIEnv& env, jni::Object<RectF> rectf) {
-    static auto javaClass = jni::Class<RectF>::Singleton(env);
+float RectF::getLeft(jni::JNIEnv& env, const jni::Object<RectF>& rectf) {
+    static auto& javaClass = jni::Class<RectF>::Singleton(env);
     static auto field = javaClass.GetField<float>(env, "left");
     return rectf.Get(env, field);
 }
 
-float RectF::getTop(jni::JNIEnv& env, jni::Object<RectF> rectf) {
-    static auto javaClass = jni::Class<RectF>::Singleton(env);
+float RectF::getTop(jni::JNIEnv& env, const jni::Object<RectF>& rectf) {
+    static auto& javaClass = jni::Class<RectF>::Singleton(env);
     static auto field = javaClass.GetField<float>(env, "top");
     return rectf.Get(env, field);
 }
 
-float RectF::getRight(jni::JNIEnv& env, jni::Object<RectF> rectf) {
-    static auto javaClass = jni::Class<RectF>::Singleton(env);
+float RectF::getRight(jni::JNIEnv& env, const jni::Object<RectF>& rectf) {
+    static auto& javaClass = jni::Class<RectF>::Singleton(env);
     static auto field = javaClass.GetField<float>(env, "right");
     return rectf.Get(env, field);
 }
 
-float RectF::getBottom(jni::JNIEnv& env, jni::Object<RectF> rectf) {
-    static auto javaClass = jni::Class<RectF>::Singleton(env);
+float RectF::getBottom(jni::JNIEnv& env, const jni::Object<RectF>& rectf) {
+    static auto& javaClass = jni::Class<RectF>::Singleton(env);
     static auto field = javaClass.GetField<float>(env, "bottom");
     return rectf.Get(env, field);
 }

platform/android/src/graphics/rectf.hpp

@@ -12,13 +12,13 @@ public:
 
     static constexpr auto Name() { return "android/graphics/RectF"; };
 
-    static float getLeft(jni::JNIEnv&, jni::Object<RectF>);
+    static float getLeft(jni::JNIEnv&, const jni::Object<RectF>&);
 
-    static float getTop(jni::JNIEnv&, jni::Object<RectF>);
+    static float getTop(jni::JNIEnv&, const jni::Object<RectF>&);
 
-    static float getRight(jni::JNIEnv&, jni::Object<RectF>);
+    static float getRight(jni::JNIEnv&, const jni::Object<RectF>&);
 
-    static float getBottom(jni::JNIEnv&, jni::Object<RectF>);
+    static float getBottom(jni::JNIEnv&, const jni::Object<RectF>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/gson/json_array.cpp

@@ -5,25 +5,25 @@ namespace mbgl {
 namespace android {
 namespace gson {
 
-jni::Object<JsonArray> JsonArray::New(jni::JNIEnv& env, const std::vector<mbgl::Value>& values){
-    static auto javaClass = jni::Class<JsonArray>::Singleton(env);
+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 = javaClass.New(env, constructor);
 
     for (const auto &v : values) {
-        jsonArray.Call(env, addMethod, *jni::SeizeLocal(env, JsonElement::New(env, v)));
+        jsonArray.Call(env, addMethod, JsonElement::New(env, v));
     }
 
     return jsonArray;
 }
 
-std::vector<mbgl::Value> JsonArray::convert(jni::JNIEnv& env, const jni::Object<JsonArray> jsonArray) {
+std::vector<mbgl::Value> JsonArray::convert(jni::JNIEnv& env, const jni::Object<JsonArray>& jsonArray) {
     std::vector<mbgl::Value> values;
 
     if (jsonArray) {
-        static auto javaClass = jni::Class<JsonArray>::Singleton(env);
+        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");
 
@@ -31,9 +31,9 @@ std::vector<mbgl::Value> JsonArray::convert(jni::JNIEnv& env, const jni::Object<
         values.reserve(uint(size));
 
         for (int i = 0; i < size; i++) {
-            auto entry = jni::SeizeLocal(env, jsonArray.Call(env, getMethod, i));
-            if (*entry) {
-                values.push_back(JsonElement::convert(env, *entry));
+            auto entry = jsonArray.Call(env, getMethod, i);
+            if (entry) {
+                values.push_back(JsonElement::convert(env, entry));
             }
         }
     }

platform/android/src/gson/json_array.hpp

@@ -8,12 +8,13 @@ namespace mbgl {
 namespace android {
 namespace gson {
 
-class JsonArray : public JsonElement {
+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<mbgl::Value>&);
-    static std::vector<mbgl::Value> convert(JNIEnv&, jni::Object<JsonArray>);
+    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&);
 };

platform/android/src/gson/json_element.cpp

@@ -7,35 +7,30 @@ namespace mbgl {
 namespace android {
 namespace gson {
 
-jni::Object<JsonElement> JsonElement::New(jni::JNIEnv& env, const mbgl::Value& value) {
-    static auto primitive = jni::Class<JsonPrimitive>::Singleton(env);
+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::Object<JsonElement>();
+            return jni::Local<jni::Object<JsonElement>>();
         },
         [&] (const std::string& value) {
-            return primitive.New(env, stringConstructor,
-                *jni::SeizeLocal(env, jni::Make<jni::String>(env, value)));
+            return primitive.New(env, stringConstructor, jni::Make<jni::String>(env, value));
         },
         [&] (const double value) {
-            return primitive.New(env, numberConstructor,
-                *jni::SeizeLocal(env, jni::Number(jni::Box(env, value))));
+            return primitive.New(env, numberConstructor, jni::Box(env, value));
         },
         [&] (const int64_t value) {
-            return primitive.New(env, numberConstructor,
-                *jni::SeizeLocal(env, jni::Number(jni::Box(env, value))));
+            return primitive.New(env, numberConstructor, jni::Box(env, value));
         },
         [&] (const uint64_t value) {
-            return primitive.New(env, numberConstructor,
-                *jni::SeizeLocal(env, jni::Number(jni::Box(env, int64_t(value))))); // TODO: should use BigInteger
+            return primitive.New(env, numberConstructor, jni::Box(env, int64_t(value))); // TODO: should use BigInteger
         },
         [&] (const bool value) {
-            return primitive.New(env, booleanConstructor,
-                *jni::SeizeLocal(env, jni::Box(env, value ? jni::jni_true : jni::jni_false)));
+            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);
@@ -46,17 +41,17 @@ jni::Object<JsonElement> JsonElement::New(jni::JNIEnv& env, const mbgl::Value& v
     );
 }
 
-mbgl::Value JsonElement::convert(jni::JNIEnv &env, jni::Object<JsonElement> jsonElement) {
+mbgl::Value JsonElement::convert(jni::JNIEnv &env, const jni::Object<JsonElement>& jsonElement) {
     if (!jsonElement) {
         return mbgl::NullValue();
     }
 
-    static auto elementClass = jni::Class<JsonElement>::Singleton(env);
+    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& 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");
@@ -71,7 +66,7 @@ mbgl::Value JsonElement::convert(jni::JNIEnv &env, jni::Object<JsonElement> json
         } 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, *jni::SeizeLocal(env, primitive.Call(env, getAsString)));
+            return jni::Make<std::string>(env, primitive.Call(env, getAsString));
         } else {
             return mbgl::NullValue();
         }

platform/android/src/gson/json_element.hpp

@@ -8,12 +8,13 @@ namespace mbgl {
 namespace android {
 namespace gson {
 
-class JsonElement : public jni::ObjectTag {
+class JsonElement {
 public:
+    using SuperTag = jni::ObjectTag;
     static constexpr auto Name() { return "com/google/gson/JsonElement"; };
 
-    static jni::Object<JsonElement> New(jni::JNIEnv&, const mbgl::Value&);
-    static mbgl::Value convert(JNIEnv&, jni::Object<JsonElement>);
+    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&);
 };

platform/android/src/gson/json_object.cpp

@@ -9,48 +9,46 @@ namespace android {
 namespace gson {
 
 
-jni::Object<JsonObject> JsonObject::New(jni::JNIEnv& env, const mbgl::PropertyMap& values) {
-    static auto javaClass = jni::Class<JsonObject>::Singleton(env);
+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 = javaClass.New(env, constructor);
+    auto jsonObject = javaClass.New(env, constructor);
 
     for (auto &item : values) {
         jsonObject.Call(env, addMethod,
-            *jni::SeizeLocal(env, jni::Make<jni::String>(env, item.first)),
-            *jni::SeizeLocal(env, JsonElement::New(env, item.second)));
+            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 javaClass = jni::Class<JsonObject>::Singleton(env);
+    static auto& javaClass = jni::Class<JsonObject>::Singleton(env);
     static auto method = javaClass.GetMethod<jni::Object<java::util::Set> ()>(env, "entrySet");
 
-    auto entryArray =
-        jni::SeizeLocal(env, java::util::Set::toArray<java::util::Map::Entry>(env,
-            *jni::SeizeLocal(env, jsonObject.Call(env, method))));
+    auto entryArray = java::util::Set::toArray<java::util::Map::Entry>(env, jsonObject.Call(env, method));
 
-    size_t size = entryArray->Length(env);
+    size_t size = entryArray.Length(env);
     for (size_t i = 0; i < size; i++) {
-        auto entry = jni::SeizeLocal(env, entryArray->Get(env, i));
+        auto entry = entryArray.Get(env, i);
         if (entry) {
             callback(
-                *jni::SeizeLocal(env, java::util::Map::Entry::getKey<jni::StringTag>(env, *entry)),
-                *jni::SeizeLocal(env, java::util::Map::Entry::getValue<gson::JsonElement>(env, *entry)));
+                java::util::Map::Entry::getKey<jni::StringTag>(env, entry),
+                java::util::Map::Entry::getValue<gson::JsonElement>(env, entry));
         }
     }
 }
 
-mbgl::PropertyMap JsonObject::convert(jni::JNIEnv &env, jni::Object<JsonObject> jsonObject) {
+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);
         });
     }

platform/android/src/gson/json_object.hpp

@@ -8,12 +8,13 @@ namespace mbgl {
 namespace android {
 namespace gson {
 
-class JsonObject : public JsonElement {
+class JsonObject {
 public:
+    using SuperTag = JsonElement;
     static constexpr auto Name() { return "com/google/gson/JsonObject"; };
 
-    static jni::Object<JsonObject> New(jni::JNIEnv&, const mbgl::PropertyMap&);
-    static mbgl::PropertyMap convert(JNIEnv&, jni::Object<JsonObject>);
+    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&);
 };

platform/android/src/gson/json_primitive.hpp

@@ -8,8 +8,9 @@ namespace mbgl {
 namespace android {
 namespace gson {
 
-class JsonPrimitive : public JsonElement {
+class JsonPrimitive {
 public:
+    using SuperTag = JsonElement;
     static constexpr auto Name() { return "com/google/gson/JsonPrimitive"; };
 
     static void registerNative(jni::JNIEnv&);

platform/android/src/http_file_source.cpp

@@ -25,12 +25,12 @@ public:
     HTTPRequest(jni::JNIEnv&, const Resource&, FileSource::Callback);
     ~HTTPRequest();
 
-    void onFailure(jni::JNIEnv&, int type, jni::String message);
+    void onFailure(jni::JNIEnv&, int type, const jni::String& message);
     void onResponse(jni::JNIEnv&, int code,
-                    jni::String etag, jni::String modified,
-                    jni::String cacheControl, jni::String expires,
-                    jni::String retryAfter, jni::String xRateLimitReset,
-                    jni::Array<jni::jbyte> body);
+                    const jni::String& etag, const jni::String& modified,
+                    const jni::String& cacheControl, const jni::String& expires,
+                    const jni::String& retryAfter, const jni::String& xRateLimitReset,
+                    const jni::Array<jni::jbyte>& body);
 
     jni::Global<jni::Object<HTTPRequest>> javaRequest;
 
@@ -54,7 +54,7 @@ private:
 namespace android {
 
 void RegisterNativeHTTPRequest(jni::JNIEnv& env) {
-    static auto javaClass = jni::Class<HTTPRequest>::Singleton(env);
+    static auto& javaClass = jni::Class<HTTPRequest>::Singleton(env);
 
     #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
@@ -79,31 +79,32 @@ HTTPRequest::HTTPRequest(jni::JNIEnv& env, const Resource& resource_, FileSource
 
     jni::UniqueLocalFrame frame = jni::PushLocalFrame(env, 10);
 
-    static auto javaClass = jni::Class<HTTPRequest>::Singleton(env);
+    static auto& javaClass = jni::Class<HTTPRequest>::Singleton(env);
     static auto constructor =
         javaClass.GetConstructor<jni::jlong, jni::String, jni::String, jni::String>(env);
 
-    javaRequest = javaClass.New(env, constructor,
-        reinterpret_cast<jlong>(this),
-        jni::Make<jni::String>(env, resource.url),
-        jni::Make<jni::String>(env, etagStr),
-        jni::Make<jni::String>(env, modifiedStr)).NewGlobalRef(env);
+    javaRequest = jni::NewGlobal(env,
+        javaClass.New(env, constructor,
+            reinterpret_cast<jlong>(this),
+            jni::Make<jni::String>(env, resource.url),
+            jni::Make<jni::String>(env, etagStr),
+            jni::Make<jni::String>(env, modifiedStr)));
 }
 
 HTTPRequest::~HTTPRequest() {
     android::UniqueEnv env = android::AttachEnv();
 
-    static auto javaClass = jni::Class<HTTPRequest>::Singleton(*env);
+    static auto& javaClass = jni::Class<HTTPRequest>::Singleton(*env);
     static auto cancel = javaClass.GetMethod<void ()>(*env, "cancel");
 
-    javaRequest->Call(*env, cancel);
+    javaRequest.Call(*env, cancel);
 }
 
 void HTTPRequest::onResponse(jni::JNIEnv& env, int code,
-                             jni::String etag, jni::String modified,
-                             jni::String cacheControl, jni::String expires,
-                             jni::String jRetryAfter, jni::String jXRateLimitReset,
-                             jni::Array<jni::jbyte> body) {
+                             const jni::String& etag, const jni::String& modified,
+                             const jni::String& cacheControl, const jni::String& expires,
+                             const jni::String& jRetryAfter, const jni::String& jXRateLimitReset,
+                             const jni::Array<jni::jbyte>& body) {
 
     using Error = Response::Error;
 
@@ -158,7 +159,7 @@ void HTTPRequest::onResponse(jni::JNIEnv& env, int code,
     async.send();
 }
 
-void HTTPRequest::onFailure(jni::JNIEnv& env, int type, jni::String message) {
+void HTTPRequest::onFailure(jni::JNIEnv& env, int type, const jni::String& message) {
     std::string messageStr = jni::Make<std::string>(env, message);
 
     using Error = Response::Error;

platform/android/src/image.cpp

@@ -11,12 +11,11 @@ namespace mbgl {
 PremultipliedImage decodeImage(const std::string& string) {
     auto env{ android::AttachEnv() };
 
-    auto array = jni::SeizeLocal(*env, jni::Array<jni::jbyte>::New(*env, string.size()));
-    jni::SetArrayRegion(*env, **array, 0, string.size(),
+    auto array = jni::Array<jni::jbyte>::New(*env, string.size());
+    jni::SetArrayRegion(*env, *array, 0, string.size(),
                         reinterpret_cast<const signed char*>(string.data()));
 
-    return android::Bitmap::GetImage(*env,
-        *jni::SeizeLocal(*env, android::BitmapFactory::DecodeByteArray(*env, *array, 0, string.size())));
+    return android::Bitmap::GetImage(*env, android::BitmapFactory::DecodeByteArray(*env, array, 0, string.size()));
 }
 
 } // namespace mbgl

platform/android/src/java/util.hpp

@@ -14,10 +14,11 @@ public:
     static constexpr auto Name() { return "java/util/List"; };
 
     template<class T>
-    static jni::Array<jni::Object<T>> toArray(jni::JNIEnv& env, jni::Object<List> list) {
-        static auto javaClass = jni::Class<List>::Singleton(env);
+    static jni::Local<jni::Array<jni::Object<T>>> toArray(jni::JNIEnv& env, const jni::Object<List>& list) {
+        static auto& javaClass = jni::Class<List>::Singleton(env);
         static auto toArray = javaClass.GetMethod<jni::Array<jni::Object<>> ()>(env, "toArray");
-        return (jni::Array<jni::Object<T>>) list.Call(env, toArray);
+
+        return jni::Local<jni::Array<jni::Object<T>>>(env, list.Call(env, toArray).release());
     };
 };
 
@@ -26,10 +27,12 @@ public:
     static constexpr auto Name() { return "java/util/Arrays"; };
 
     template <class T>
-    static jni::Object<List> asList(jni::JNIEnv& env, jni::Array<jni::Object<T>> array) {
-        static auto javaClass = jni::Class<Arrays>::Singleton(env);
+    static jni::Local<jni::Object<List>> asList(jni::JNIEnv& env, const jni::Array<jni::Object<T>>& array) {
+        static auto& javaClass = jni::Class<Arrays>::Singleton(env);
         static auto asList = javaClass.GetStaticMethod<jni::Object<List>(jni::Array<jni::Object<>>)>(env, "asList");
-        return javaClass.Call(env, asList, (jni::Array<jni::Object<>>) array);
+
+        auto typeErasedArray = jni::Local<jni::Array<jni::Object<>>>(env, jni::NewLocal(env, array).release());
+        return javaClass.Call(env, asList, typeErasedArray);
     }
 };
 
@@ -38,10 +41,11 @@ public:
     static constexpr auto Name() { return "java/util/Set"; };
 
     template<class T>
-    static jni::Array<jni::Object<T>> toArray(jni::JNIEnv& env, jni::Object<Set> list) {
-        static auto javaClass = jni::Class<Set>::Singleton(env);
+    static jni::Local<jni::Array<jni::Object<T>>> toArray(jni::JNIEnv& env, const jni::Object<Set>& list) {
+        static auto& javaClass = jni::Class<Set>::Singleton(env);
         static auto toArray = javaClass.GetMethod<jni::Array<jni::Object<>> ()>(env, "toArray");
-        return (jni::Array<jni::Object<T>>) list.Call(env, toArray);
+
+        return jni::Local<jni::Array<jni::Object<T>>>(env, list.Call(env, toArray).release());
     };
 };
 
@@ -54,15 +58,15 @@ public:
         static constexpr auto Name() { return "java/util/Map$Entry"; };
 
         template <class T>
-        static jni::Object<T> getKey(jni::JNIEnv& env, jni::Object<Entry> entry) {
-            static auto javaClass = jni::Class<Map::Entry>::Singleton(env);
+        static jni::Local<jni::Object<T>> getKey(jni::JNIEnv& env, const jni::Object<Entry>& entry) {
+            static auto& javaClass = jni::Class<Map::Entry>::Singleton(env);
             static auto method = javaClass.GetMethod<jni::Object<> ()>(env, "getKey");
             return jni::Cast(env, jni::Class<T>::Singleton(env), entry.Call(env, method));
         }
 
         template <class T>
-        static jni::Object<T> getValue(jni::JNIEnv& env, jni::Object<Entry> entry) {
-            static auto javaClass = jni::Class<Map::Entry>::Singleton(env);
+        static jni::Local<jni::Object<T>> getValue(jni::JNIEnv& env, const jni::Object<Entry>& entry) {
+            static auto& javaClass = jni::Class<Map::Entry>::Singleton(env);
             static auto method = javaClass.GetMethod<jni::Object<> ()>(env, "getValue");
             return jni::Cast(env, jni::Class<T>::Singleton(env), entry.Call(env, method));
         }

platform/android/src/jni/generic_global_ref_deleter.hpp

@@ -1,45 +0,0 @@
-#pragma once
-
-#include <jni/jni.hpp>
-
-#include "../attach_env.hpp"
-
-namespace mbgl {
-namespace android {
-
-// A deleter that doesn't retain an JNIEnv handle but instead tries to attach the JVM. This means
-// it can be used on any thread to delete a global ref.
-struct GenericGlobalRefDeleter {
-    void operator()(jni::jobject* p) const {
-        if (p) {
-            AttachEnv()->DeleteGlobalRef(jni::Unwrap(p));
-        }
-    }
-};
-
-struct GenericWeakGlobalRefDeleter {
-    void operator()(jni::jobject* p) const {
-        if (p) {
-            AttachEnv()->DeleteWeakGlobalRef(jni::Unwrap(p));
-        }
-    }
-};
-
-template < class T >
-using GenericGlobal = jni::UniquePointerlike< T, GenericGlobalRefDeleter >;
-
-template < class T >
-using GenericWeak = jni::UniquePointerlike< T, GenericWeakGlobalRefDeleter >;
-
-template < class T >
-GenericGlobal<T> SeizeGenericGlobal(T&& t) {
-    return GenericGlobal<T>(std::move(t), GenericGlobalRefDeleter());
-};
-
-template < class T >
-GenericWeak<T> SeizeGenericWeak(T&& t) {
-    return GenericWeak<T>(std::move(t), GenericWeakGlobalRefDeleter());
-};
-
-} // namespace android
-} // namespace mbgl

platform/android/src/logger.cpp

@@ -9,24 +9,24 @@ void Logger::registerNative(jni::JNIEnv& env) {
 }
 
 void Logger::log(jni::JNIEnv& env, EventSeverity severity, const std::string &msg) {
-    static auto _class = jni::Class<Logger>::Singleton(env);
+    static auto& _class = jni::Class<Logger>::Singleton(env);
 
-    auto tag = jni::SeizeLocal(env, jni::Make<jni::String>(env, "Mbgl"));
-    auto message = jni::SeizeLocal(env, jni::Make<jni::String>(env, msg));
+    auto tag = jni::Make<jni::String>(env, "Mbgl");
+    auto message = jni::Make<jni::String>(env, msg);
     using Signature = void(jni::String, jni::String);
 
     if (severity == EventSeverity::Debug) {
         auto static debug = _class.GetStaticMethod<Signature>(env, "d");
-        _class.Call(env, debug, *tag, *message);
+        _class.Call(env, debug, tag, message);
     } else if (severity == EventSeverity::Info) {
         auto static info = _class.GetStaticMethod<Signature>(env, "i");
-        _class.Call(env, info, *tag, *message);
+        _class.Call(env, info, tag, message);
     } else if(severity == EventSeverity::Warning) {
         auto static warning = _class.GetStaticMethod<Signature>(env, "w");
-        _class.Call(env, warning, *tag, *message);
+        _class.Call(env, warning, tag, message);
     } else {
         auto static error = _class.GetStaticMethod<Signature>(env, "e");
-        _class.Call(env, error, *tag, *message);
+        _class.Call(env, error, tag, message);
     }
 }
 

platform/android/src/map/camera_position.cpp

@@ -4,8 +4,8 @@
 namespace mbgl {
 namespace android {
 
-jni::Object<CameraPosition> CameraPosition::New(jni::JNIEnv &env, mbgl::CameraOptions options) {
-    static auto javaClass = jni::Class<CameraPosition>::Singleton(env);
+jni::Local<jni::Object<CameraPosition>> CameraPosition::New(jni::JNIEnv &env, mbgl::CameraOptions options) {
+    static auto& javaClass = jni::Class<CameraPosition>::Singleton(env);
     static auto constructor = javaClass.GetConstructor<jni::Object<LatLng>, double, double, double>(env);
 
     // wrap LatLng values coming from core
@@ -28,14 +28,14 @@ jni::Object<CameraPosition> CameraPosition::New(jni::JNIEnv &env, mbgl::CameraOp
     return javaClass.New(env, constructor, LatLng::New(env, center), options.zoom.value_or(0), tilt_degrees, bearing_degrees);
 }
 
-mbgl::CameraOptions CameraPosition::getCameraOptions(jni::JNIEnv& env, jni::Object<CameraPosition> position) {
-    static auto javaClass = jni::Class<CameraPosition>::Singleton(env);
+mbgl::CameraOptions CameraPosition::getCameraOptions(jni::JNIEnv& env, const jni::Object<CameraPosition>& position) {
+    static auto& javaClass = jni::Class<CameraPosition>::Singleton(env);
     static auto bearing = javaClass.GetField<jni::jdouble>(env, "bearing");
     static auto target = javaClass.GetField<jni::Object<LatLng>>(env, "target");
     static auto tilt = javaClass.GetField<jni::jdouble>(env, "tilt");
     static auto zoom = javaClass.GetField<jni::jdouble>(env, "zoom");
 
-    auto center = LatLng::getLatLng(env, *jni::SeizeLocal(env, position.Get(env, target)));
+    auto center = LatLng::getLatLng(env, position.Get(env, target));
 
     return mbgl::CameraOptions {
             center,

platform/android/src/map/camera_position.hpp

@@ -12,9 +12,9 @@ class CameraPosition : private mbgl::util::noncopyable {
 public:
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/camera/CameraPosition"; };
 
-    static jni::Object<CameraPosition> New(jni::JNIEnv&, mbgl::CameraOptions);
+    static jni::Local<jni::Object<CameraPosition>> New(jni::JNIEnv&, mbgl::CameraOptions);
 
-    static mbgl::CameraOptions getCameraOptions(jni::JNIEnv&, jni::Object<CameraPosition>);
+    static mbgl::CameraOptions getCameraOptions(jni::JNIEnv&, const jni::Object<CameraPosition>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/map/image.cpp

@@ -5,8 +5,8 @@
 namespace mbgl {
 namespace android {
 
-mbgl::style::Image Image::getImage(jni::JNIEnv& env, jni::Object<Image> image) {
-    static auto javaClass = jni::Class<Image>::Singleton(env);
+mbgl::style::Image Image::getImage(jni::JNIEnv& env, const jni::Object<Image>& image) {
+    static auto& javaClass = jni::Class<Image>::Singleton(env);
     static auto widthField = javaClass.GetField<jni::jint>(env, "width");
     static auto heightField = javaClass.GetField<jni::jint>(env, "height");
     static auto pixelRatioField = javaClass.GetField<jni::jfloat>(env, "pixelRatio");
@@ -17,19 +17,19 @@ mbgl::style::Image Image::getImage(jni::JNIEnv& env, jni::Object<Image> image) {
     auto height = image.Get(env, heightField);
     auto width = image.Get(env, widthField);
     auto pixelRatio = image.Get(env, pixelRatioField);
-    auto pixels = jni::SeizeLocal(env, image.Get(env, bufferField));
-    auto name = jni::Make<std::string>(env, *jni::SeizeLocal(env, image.Get(env, nameField)));
+    auto pixels = image.Get(env, bufferField);
+    auto name = jni::Make<std::string>(env, image.Get(env, nameField));
     auto sdf = (bool) image.Get(env, sdfField);
 
-    jni::NullCheck(env, pixels->Get());
-    std::size_t size = pixels->Length(env);
+    jni::NullCheck(env, pixels.get());
+    std::size_t size = pixels.Length(env);
 
     mbgl::PremultipliedImage premultipliedImage({ static_cast<uint32_t>(width), static_cast<uint32_t>(height) });
     if (premultipliedImage.bytes() != uint32_t(size)) {
         throw mbgl::util::SpriteImageException("Sprite image pixel count mismatch");
     }
 
-    jni::GetArrayRegion(env, **pixels, 0, size, reinterpret_cast<jbyte*>(premultipliedImage.data.get()));
+    jni::GetArrayRegion(env, *pixels, 0, size, reinterpret_cast<jbyte*>(premultipliedImage.data.get()));
     return mbgl::style::Image {name, std::move(premultipliedImage), pixelRatio, sdf};
 }
 

platform/android/src/map/image.hpp

@@ -12,7 +12,7 @@ class Image : private mbgl::util::noncopyable {
 public:
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/maps/Image"; };
 
-    static mbgl::style::Image getImage(jni::JNIEnv&, jni::Object<Image>);
+    static mbgl::style::Image getImage(jni::JNIEnv&, const jni::Object<Image>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/map_renderer.cpp

@@ -14,15 +14,17 @@
 namespace mbgl {
 namespace android {
 
-MapRenderer::MapRenderer(jni::JNIEnv& _env, jni::Object<MapRenderer> obj,
-                         jni::Object<FileSource> _fileSource, jni::jfloat pixelRatio_,
-                         jni::String programCacheDir_,
-                         jni::String localIdeographFontFamily_)
-        : javaPeer(SeizeGenericWeak(obj.NewWeakGlobalRef(_env).release()))
+MapRenderer::MapRenderer(jni::JNIEnv& _env,
+                         const jni::Object<MapRenderer>& obj,
+                         const jni::Object<FileSource>& _fileSource,
+                         jni::jfloat pixelRatio_,
+                         const jni::String& programCacheDir_,
+                         const jni::String& localIdeographFontFamily_)
+        : javaPeer(_env, obj)
         , pixelRatio(pixelRatio_)
         , fileSource(FileSource::getDefaultFileSource(_env, _fileSource))
         , programCacheDir(jni::Make<std::string>(_env, programCacheDir_))
-        , localIdeographFontFamily(localIdeographFontFamily_ == nullptr ? optional<std::string>{} : jni::Make<std::string>(_env, localIdeographFontFamily_ ))
+        , localIdeographFontFamily(localIdeographFontFamily_ ? jni::Make<std::string>(_env, localIdeographFontFamily_) : optional<std::string>{})
         , threadPool(sharedThreadPool())
         , mailbox(std::make_shared<Mailbox>(*this)) {
 }
@@ -53,10 +55,10 @@ void MapRenderer::schedule(std::weak_ptr<Mailbox> scheduled) {
     auto peer = runnable->peer();
 
     // Queue the event on the Java Peer
-    static auto javaClass = jni::Class<MapRenderer>::Singleton(*_env);
+    static auto& javaClass = jni::Class<MapRenderer>::Singleton(*_env);
     static auto queueEvent = javaClass.GetMethod<void(
             jni::Object<MapRendererRunnable>)>(*_env, "queueEvent");
-    javaPeer->Call(*_env, queueEvent, *peer);
+    javaPeer.get(*_env).Call(*_env, queueEvent, peer);
 
     // Release the c++ peer as it will be destroyed on GC of the Java Peer
     runnable.release();
@@ -64,9 +66,9 @@ void MapRenderer::schedule(std::weak_ptr<Mailbox> scheduled) {
 
 void MapRenderer::requestRender() {
     android::UniqueEnv _env = android::AttachEnv();
-    static auto javaClass = jni::Class<MapRenderer>::Singleton(*_env);
+    static auto& javaClass = jni::Class<MapRenderer>::Singleton(*_env);
     static auto onInvalidate = javaClass.GetMethod<void()>(*_env, "requestRender");
-    javaPeer->Call(*_env, onInvalidate);
+    javaPeer.get(*_env).Call(*_env, onInvalidate);
 }
 
 void MapRenderer::update(std::shared_ptr<UpdateParameters> params) {
@@ -184,13 +186,13 @@ void MapRenderer::onSurfaceChanged(JNIEnv&, jint width, jint height) {
 
 void MapRenderer::registerNative(jni::JNIEnv& env) {
     // Lookup the class
-    static auto javaClass = jni::Class<MapRenderer>::Singleton(env);
+    static auto& javaClass = jni::Class<MapRenderer>::Singleton(env);
 
 #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
     // Register the peer
     jni::RegisterNativePeer<MapRenderer>(env, javaClass, "nativePtr",
-                                         std::make_unique<MapRenderer, JNIEnv&, jni::Object<MapRenderer>, jni::Object<FileSource>, jni::jfloat, jni::String, jni::String>,
+                                         jni::MakePeer<MapRenderer, const jni::Object<MapRenderer>&, const jni::Object<FileSource>&, jni::jfloat, const jni::String&, const jni::String&>,
                                          "nativeInitialize", "finalize",
                                          METHOD(&MapRenderer::render, "nativeRender"),
                                          METHOD(&MapRenderer::onSurfaceCreated,
@@ -199,8 +201,8 @@ void MapRenderer::registerNative(jni::JNIEnv& env) {
                                                 "nativeOnSurfaceChanged"));
 }
 
-MapRenderer& MapRenderer::getNativePeer(JNIEnv& env, jni::Object<MapRenderer> jObject) {
-    static auto javaClass = jni::Class<MapRenderer>::Singleton(env);
+MapRenderer& MapRenderer::getNativePeer(JNIEnv& env, const jni::Object<MapRenderer>& jObject) {
+    static auto& javaClass = jni::Class<MapRenderer>::Singleton(env);
     static auto field = javaClass.GetField<jlong>(env, "nativePtr");
     MapRenderer* mapRenderer = reinterpret_cast<MapRenderer*>(jObject.Get(env, field));
     assert(mapRenderer != nullptr);

platform/android/src/map_renderer.hpp

@@ -9,8 +9,6 @@
 #include <jni/jni.hpp>
 #include <mbgl/storage/default_file_source.hpp>
 
-#include "jni/generic_global_ref_deleter.hpp"
-
 namespace mbgl {
 
 template <class>
@@ -40,14 +38,14 @@ public:
 
     static void registerNative(jni::JNIEnv&);
 
-    static MapRenderer& getNativePeer(JNIEnv&, jni::Object<MapRenderer>);
+    static MapRenderer& getNativePeer(JNIEnv&, const jni::Object<MapRenderer>&);
 
     MapRenderer(jni::JNIEnv& _env,
-                jni::Object<MapRenderer>,
-                jni::Object<FileSource>,
+                const jni::Object<MapRenderer>&,
+                const jni::Object<FileSource>&,
                 jni::jfloat pixelRatio,
-                jni::String programCacheDir,
-                jni::String localIdeographFontFamily);
+                const jni::String& programCacheDir,
+                const jni::String& localIdeographFontFamily);
 
     ~MapRenderer() override;
 
@@ -97,7 +95,7 @@ private:
     void onSurfaceChanged(JNIEnv&, jint width, jint height);
 
 private:
-    GenericWeak<jni::Object<MapRenderer>> javaPeer;
+    jni::WeakReference<jni::Object<MapRenderer>, jni::EnvAttachingDeleter> javaPeer;
 
     float pixelRatio;
     DefaultFileSource& fileSource;

platform/android/src/map_renderer_runnable.cpp

@@ -12,10 +12,10 @@ MapRendererRunnable::MapRendererRunnable(jni::JNIEnv& env, std::weak_ptr<Mailbox
     // Not using a weak reference here as this might oerflow
     // the weak reference table on some devices
     jni::UniqueLocalFrame frame = jni::PushLocalFrame(env, 5);
-    static auto javaClass = jni::Class<MapRendererRunnable>::Singleton(env);
+    static auto& javaClass = jni::Class<MapRendererRunnable>::Singleton(env);
     static auto constructor = javaClass.GetConstructor<jlong>(env);
     auto instance = javaClass.New(env, constructor, reinterpret_cast<jlong>(this));
-    javaPeer = instance.NewGlobalRef(env);
+    javaPeer = jni::NewGlobal(env, instance);
 }
 
 MapRendererRunnable::~MapRendererRunnable() = default;
@@ -32,7 +32,7 @@ jni::Global<jni::Object<MapRendererRunnable>> MapRendererRunnable::peer() {
 
 void MapRendererRunnable::registerNative(jni::JNIEnv& env) {
     // Lookup the class
-    static auto javaClass = jni::Class<MapRendererRunnable>::Singleton(env);
+    static auto& javaClass = jni::Class<MapRendererRunnable>::Singleton(env);
 
 #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 

platform/android/src/native_map_view.cpp

@@ -57,11 +57,11 @@ namespace mbgl {
 namespace android {
 
 NativeMapView::NativeMapView(jni::JNIEnv& _env,
-                             jni::Object<NativeMapView> _obj,
-                             jni::Object<FileSource> jFileSource,
-                             jni::Object<MapRenderer> jMapRenderer,
+                             const jni::Object<NativeMapView>& _obj,
+                             const jni::Object<FileSource>& jFileSource,
+                             const jni::Object<MapRenderer>& jMapRenderer,
                              jni::jfloat _pixelRatio)
-    : javaPeer(_obj.NewWeakGlobalRef(_env))
+    : javaPeer(_env, _obj)
     , mapRenderer(MapRenderer::getNativePeer(_env, jMapRenderer))
     , pixelRatio(_pixelRatio)
     , threadPool(sharedThreadPool()) {
@@ -103,9 +103,9 @@ void NativeMapView::notifyMapChange(mbgl::MapChange change) {
     assert(vm != nullptr);
 
     android::UniqueEnv _env = android::AttachEnv();
-    static auto javaClass = jni::Class<NativeMapView>::Singleton(*_env);
+    static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
     static auto onMapChanged = javaClass.GetMethod<void (int)>(*_env, "onMapChanged");
-    javaPeer->Call(*_env, onMapChanged, (int) change);
+    javaPeer.get(*_env).Call(*_env, onMapChanged, (int) change);
 }
 
 void NativeMapView::onCameraWillChange(MapObserver::CameraChangeMode mode) {
@@ -180,23 +180,23 @@ void NativeMapView::resizeView(jni::JNIEnv&, int w, int h) {
     map->setSize({ static_cast<uint32_t>(width), static_cast<uint32_t>(height) });
 }
 
-jni::String NativeMapView::getStyleUrl(jni::JNIEnv& env) {
+jni::Local<jni::String> NativeMapView::getStyleUrl(jni::JNIEnv& env) {
     return jni::Make<jni::String>(env, map->getStyle().getURL());
 }
 
-void NativeMapView::setStyleUrl(jni::JNIEnv& env, jni::String url) {
+void NativeMapView::setStyleUrl(jni::JNIEnv& env, const jni::String& url) {
     map->getStyle().loadURL(jni::Make<std::string>(env, url));
 }
 
-jni::String NativeMapView::getStyleJson(jni::JNIEnv& env) {
+jni::Local<jni::String> NativeMapView::getStyleJson(jni::JNIEnv& env) {
     return jni::Make<jni::String>(env, map->getStyle().getJSON());
 }
 
-void NativeMapView::setStyleJson(jni::JNIEnv& env, jni::String json) {
+void NativeMapView::setStyleJson(jni::JNIEnv& env, const jni::String& json) {
     map->getStyle().loadJSON(jni::Make<std::string>(env, json));
 }
 
-void NativeMapView::setLatLngBounds(jni::JNIEnv& env, jni::Object<mbgl::android::LatLngBounds> jBounds) {
+void NativeMapView::setLatLngBounds(jni::JNIEnv& env, const jni::Object<mbgl::android::LatLngBounds>& jBounds) {
     if (jBounds) {
         map->setLatLngBounds(mbgl::android::LatLngBounds::getLatLngBounds(env, jBounds));
     } else {
@@ -281,7 +281,7 @@ void NativeMapView::flyTo(jni::JNIEnv&, jni::jdouble angle, jni::jdouble latitud
     map->flyTo(cameraOptions, animationOptions);
 }
 
-jni::Object<LatLng> NativeMapView::getLatLng(JNIEnv& env) {
+jni::Local<jni::Object<LatLng>> NativeMapView::getLatLng(JNIEnv& env) {
     return LatLng::New(env, map->getLatLng(insets));
 }
 
@@ -289,12 +289,12 @@ void NativeMapView::setLatLng(jni::JNIEnv&, jni::jdouble latitude, jni::jdouble
     map->setLatLng(mbgl::LatLng(latitude, longitude), insets, mbgl::AnimationOptions{mbgl::Milliseconds(duration)});
 }
 
-jni::Object<CameraPosition> NativeMapView::getCameraForLatLngBounds(jni::JNIEnv& env, jni::Object<LatLngBounds> jBounds, double top, double left, double bottom, double right, double bearing, double tilt) {
+jni::Local<jni::Object<CameraPosition>> NativeMapView::getCameraForLatLngBounds(jni::JNIEnv& env, const jni::Object<LatLngBounds>& jBounds, double top, double left, double bottom, double right, double bearing, double tilt) {
     mbgl::EdgeInsets padding = {top, left, bottom, right};
     return CameraPosition::New(env, map->cameraForLatLngBounds(mbgl::android::LatLngBounds::getLatLngBounds(env, jBounds), padding, bearing, tilt));
 }
 
-jni::Object<CameraPosition> NativeMapView::getCameraForGeometry(jni::JNIEnv& env, jni::Object<geojson::Geometry> jGeometry, double top, double left, double bottom, double right, double bearing, double tilt) {
+jni::Local<jni::Object<CameraPosition>> NativeMapView::getCameraForGeometry(jni::JNIEnv& env, const jni::Object<geojson::Geometry>& jGeometry, double top, double left, double bottom, double right, double bearing, double tilt) {
     auto geometry = geojson::Geometry::convert(env, jGeometry);
     mbgl::EdgeInsets padding = {top, left, bottom, right};
     return CameraPosition::New(env, map->cameraForGeometry(geometry, padding, bearing, tilt));
@@ -369,7 +369,7 @@ void NativeMapView::resetNorth(jni::JNIEnv&) {
     map->resetNorth();
 }
 
-void NativeMapView::setVisibleCoordinateBounds(JNIEnv& env, jni::Array<jni::Object<LatLng>> coordinates, jni::Object<RectF> padding, jdouble direction, jni::jlong duration) {
+void NativeMapView::setVisibleCoordinateBounds(JNIEnv& env, const jni::Array<jni::Object<LatLng>>& coordinates, const jni::Object<RectF>& padding, jdouble direction, jni::jlong duration) {
     NullCheck(env, &coordinates);
     std::size_t count = coordinates.Length(env);
 
@@ -377,7 +377,7 @@ void NativeMapView::setVisibleCoordinateBounds(JNIEnv& env, jni::Array<jni::Obje
     latLngs.reserve(count);
 
     for (std::size_t i = 0; i < count; i++) {
-        latLngs.push_back(LatLng::getLatLng(env, *jni::SeizeLocal(env, coordinates.Get(env, i))));
+        latLngs.push_back(LatLng::getLatLng(env, coordinates.Get(env, i)));
     }
 
     mbgl::EdgeInsets mbglInsets = { RectF::getTop(env, padding), RectF::getLeft(env, padding), RectF::getBottom(env, padding), RectF::getRight(env, padding) };
@@ -408,17 +408,17 @@ void NativeMapView::scheduleSnapshot(jni::JNIEnv&) {
         auto bitmap = Bitmap::CreateBitmap(*_env, std::move(image));
 
         // invoke Mapview#OnSnapshotReady
-        static auto javaClass = jni::Class<NativeMapView>::Singleton(*_env);
+        static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
         static auto onSnapshotReady = javaClass.GetMethod<void (jni::Object<Bitmap>)>(*_env, "onSnapshotReady");
-        javaPeer->Call(*_env, onSnapshotReady, bitmap);
+        javaPeer.get(*_env).Call(*_env, onSnapshotReady, bitmap);
     });
 }
 
-jni::Object<CameraPosition> NativeMapView::getCameraPosition(jni::JNIEnv& env) {
+jni::Local<jni::Object<CameraPosition>> NativeMapView::getCameraPosition(jni::JNIEnv& env) {
     return CameraPosition::New(env, map->getCameraOptions(insets));
 }
 
-void NativeMapView::updateMarker(jni::JNIEnv& env, jni::jlong markerId, jni::jdouble lat, jni::jdouble lon, jni::String jid) {
+void NativeMapView::updateMarker(jni::JNIEnv& env, jni::jlong markerId, jni::jdouble lat, jni::jdouble lon, const jni::String& jid) {
     if (markerId == -1) {
         return;
     }
@@ -428,7 +428,7 @@ void NativeMapView::updateMarker(jni::JNIEnv& env, jni::jlong markerId, jni::jdo
     map->updateAnnotation(markerId, mbgl::SymbolAnnotation { mbgl::Point<double>(lon, lat), iconId });
 }
 
-jni::Array<jni::jlong> NativeMapView::addMarkers(jni::JNIEnv& env, jni::Array<jni::Object<Marker>> jmarkers) {
+jni::Local<jni::Array<jni::jlong>> NativeMapView::addMarkers(jni::JNIEnv& env, const jni::Array<jni::Object<Marker>>& jmarkers) {
     jni::NullCheck(env, &jmarkers);
     std::size_t len = jmarkers.Length(env);
 
@@ -436,10 +436,10 @@ jni::Array<jni::jlong> NativeMapView::addMarkers(jni::JNIEnv& env, jni::Array<jn
     ids.reserve(len);
 
     for (std::size_t i = 0; i < len; i++) {
-        auto marker = jni::SeizeLocal(env, jmarkers.Get(env, i));
+        auto marker = jmarkers.Get(env, i);
         ids.push_back(map->addAnnotation(mbgl::SymbolAnnotation {
-            Marker::getPosition(env, *marker),
-            Marker::getIconId(env, *marker)
+            Marker::getPosition(env, marker),
+            Marker::getIconId(env, marker)
         }));
     }
 
@@ -477,25 +477,25 @@ jni::jdouble NativeMapView::getMetersPerPixelAtLatitude(JNIEnv&, jni::jdouble la
     return mbgl::Projection::getMetersPerPixelAtLatitude(lat, zoom);
 }
 
-jni::Object<ProjectedMeters> NativeMapView::projectedMetersForLatLng(JNIEnv& env, jni::jdouble latitude, jni::jdouble longitude) {
+jni::Local<jni::Object<ProjectedMeters>> NativeMapView::projectedMetersForLatLng(JNIEnv& env, jni::jdouble latitude, jni::jdouble longitude) {
     mbgl::ProjectedMeters projectedMeters = mbgl::Projection::projectedMetersForLatLng(mbgl::LatLng(latitude, longitude));
     return ProjectedMeters::New(env, projectedMeters.northing(), projectedMeters.easting());
 }
 
-jni::Object<LatLng> NativeMapView::latLngForProjectedMeters(JNIEnv& env, jdouble northing, jdouble easting) {
+jni::Local<jni::Object<LatLng>> NativeMapView::latLngForProjectedMeters(JNIEnv& env, jdouble northing, jdouble easting) {
     return LatLng::New(env, mbgl::Projection::latLngForProjectedMeters(mbgl::ProjectedMeters(northing, easting)));
 }
 
-jni::Object<PointF> NativeMapView::pixelForLatLng(JNIEnv& env, jdouble latitude, jdouble longitude) {
+jni::Local<jni::Object<PointF>> NativeMapView::pixelForLatLng(JNIEnv& env, jdouble latitude, jdouble longitude) {
     mbgl::ScreenCoordinate pixel = map->pixelForLatLng(mbgl::LatLng(latitude, longitude));
     return PointF::New(env, static_cast<float>(pixel.x), static_cast<float>(pixel.y));
 }
 
-jni::Object<LatLng> NativeMapView::latLngForPixel(JNIEnv& env, jfloat x, jfloat y) {
+jni::Local<jni::Object<LatLng>> NativeMapView::latLngForPixel(JNIEnv& env, jfloat x, jfloat y) {
     return LatLng::New(env, map->latLngForPixel(mbgl::ScreenCoordinate(x, y)));
 }
 
-jni::Array<jlong> NativeMapView::addPolylines(JNIEnv& env, jni::Array<jni::Object<Polyline>> polylines) {
+jni::Local<jni::Array<jlong>> NativeMapView::addPolylines(JNIEnv& env, const jni::Array<jni::Object<Polyline>>& polylines) {
     NullCheck(env, &polylines);
     std::size_t len = polylines.Length(env);
 
@@ -503,7 +503,7 @@ jni::Array<jlong> NativeMapView::addPolylines(JNIEnv& env, jni::Array<jni::Objec
     ids.reserve(len);
 
     for (std::size_t i = 0; i < len; i++) {
-        mbgl::LineAnnotation annotation = Polyline::toAnnotation(env, *jni::SeizeLocal(env, polylines.Get(env, i)));
+        mbgl::LineAnnotation annotation = Polyline::toAnnotation(env, polylines.Get(env, i));
         ids.push_back(map->addAnnotation(annotation));
     }
 
@@ -514,7 +514,7 @@ jni::Array<jlong> NativeMapView::addPolylines(JNIEnv& env, jni::Array<jni::Objec
 }
 
 
-jni::Array<jlong> NativeMapView::addPolygons(JNIEnv& env, jni::Array<jni::Object<Polygon>> polygons) {
+jni::Local<jni::Array<jlong>> NativeMapView::addPolygons(JNIEnv& env, const jni::Array<jni::Object<Polygon>>& polygons) {
     NullCheck(env, &polygons);
     std::size_t len = polygons.Length(env);
 
@@ -522,7 +522,7 @@ jni::Array<jlong> NativeMapView::addPolygons(JNIEnv& env, jni::Array<jni::Object
     ids.reserve(len);
 
     for (std::size_t i = 0; i < len; i++) {
-        mbgl::FillAnnotation annotation = Polygon::toAnnotation(env, *jni::SeizeLocal(env, polygons.Get(env, i)));
+        mbgl::FillAnnotation annotation = Polygon::toAnnotation(env, polygons.Get(env, i));
         ids.push_back(map->addAnnotation(annotation));
     }
 
@@ -533,18 +533,18 @@ jni::Array<jlong> NativeMapView::addPolygons(JNIEnv& env, jni::Array<jni::Object
 }
 
 //TODO: Move to Polyline class and make native peer
-void NativeMapView::updatePolyline(JNIEnv& env, jlong polylineId, jni::Object<Polyline> polyline) {
+void NativeMapView::updatePolyline(JNIEnv& env, jlong polylineId, const jni::Object<Polyline>& polyline) {
     mbgl::LineAnnotation annotation = Polyline::toAnnotation(env, polyline);
     map->updateAnnotation(polylineId, annotation);
 }
 
 //TODO: Move to Polygon class and make native peer
-void NativeMapView::updatePolygon(JNIEnv& env, jlong polygonId, jni::Object<Polygon> polygon) {
+void NativeMapView::updatePolygon(JNIEnv& env, jlong polygonId, const jni::Object<Polygon>& polygon) {
     mbgl::FillAnnotation annotation = Polygon::toAnnotation(env, polygon);
     map->updateAnnotation(polygonId, annotation);
 }
 
-void NativeMapView::removeAnnotations(JNIEnv& env, jni::Array<jlong> ids) {
+void NativeMapView::removeAnnotations(JNIEnv& env, const jni::Array<jlong>& ids) {
     NullCheck(env, &ids);
     std::size_t len = ids.Length(env);
     auto elements = jni::GetArrayElements(env, *ids);
@@ -558,7 +558,7 @@ void NativeMapView::removeAnnotations(JNIEnv& env, jni::Array<jlong> ids) {
     }
 }
 
-void NativeMapView::addAnnotationIcon(JNIEnv& env, jni::String symbol, jint w, jint h, jfloat scale, jni::Array<jbyte> jpixels) {
+void NativeMapView::addAnnotationIcon(JNIEnv& env, const jni::String& symbol, jint w, jint h, jfloat scale, const jni::Array<jbyte>& jpixels) {
     const std::string symbolName = jni::Make<std::string>(env, symbol);
 
     NullCheck(env, &jpixels);
@@ -574,12 +574,12 @@ void NativeMapView::addAnnotationIcon(JNIEnv& env, jni::String symbol, jint w, j
         symbolName, std::move(premultipliedImage), float(scale)));
 }
 
-void NativeMapView::removeAnnotationIcon(JNIEnv& env, jni::String symbol) {
+void NativeMapView::removeAnnotationIcon(JNIEnv& env, const jni::String& symbol) {
     const std::string symbolName = jni::Make<std::string>(env, symbol);
     map->removeAnnotationImage(symbolName);
 }
 
-jdouble NativeMapView::getTopOffsetPixelsForAnnotationSymbol(JNIEnv& env, jni::String symbolName) {
+jdouble NativeMapView::getTopOffsetPixelsForAnnotationSymbol(JNIEnv& env, const jni::String& symbolName) {
     return map->getTopOffsetPixelsForAnnotationImage(jni::Make<std::string>(env, symbolName));
 }
 
@@ -605,7 +605,7 @@ void NativeMapView::setTransitionDelay(JNIEnv&, jlong delay) {
     map->getStyle().setTransitionOptions(transitionOptions);
 }
 
-jni::Array<jlong> NativeMapView::queryPointAnnotations(JNIEnv& env, jni::Object<RectF> rect) {
+jni::Local<jni::Array<jlong>> NativeMapView::queryPointAnnotations(JNIEnv& env, const jni::Object<RectF>& rect) {
     using namespace mbgl::style;
     using namespace mbgl::style::conversion;
 
@@ -626,7 +626,7 @@ jni::Array<jlong> NativeMapView::queryPointAnnotations(JNIEnv& env, jni::Object<
     return result;
 }
 
-jni::Array<jlong> NativeMapView::queryShapeAnnotations(JNIEnv &env, jni::Object<RectF> rect) {
+jni::Local<jni::Array<jlong>> NativeMapView::queryShapeAnnotations(JNIEnv& env, const jni::Object<RectF>& rect) {
     using namespace mbgl::style;
     using namespace mbgl::style::conversion;
 
@@ -646,31 +646,31 @@ jni::Array<jlong> NativeMapView::queryShapeAnnotations(JNIEnv &env, jni::Object<
     return result;
 }
 
-jni::Array<jni::Object<geojson::Feature>> NativeMapView::queryRenderedFeaturesForPoint(JNIEnv& env, jni::jfloat x, jni::jfloat y,
-                                                                              jni::Array<jni::String> layerIds,
-                                                                              jni::Array<jni::Object<>> jfilter) {
+jni::Local<jni::Array<jni::Object<geojson::Feature>>> NativeMapView::queryRenderedFeaturesForPoint(JNIEnv& env, jni::jfloat x, jni::jfloat y,
+                                                                              const jni::Array<jni::String>& layerIds,
+                                                                              const jni::Array<jni::Object<>>& jfilter) {
     using namespace mbgl::android::conversion;
     using namespace mbgl::android::geojson;
 
     mbgl::optional<std::vector<std::string>> layers;
-    if (layerIds != nullptr && layerIds.Length(env) > 0) {
+    if (layerIds && layerIds.Length(env) > 0) {
         layers = android::conversion::toVector(env, layerIds);
     }
     mapbox::geometry::point<double> point = {x, y};
 
     return Feature::convert(
             env,
-            rendererFrontend->queryRenderedFeatures(point, { layers, toFilter(env, jni::SeizeLocal(env, std::move(jfilter))) }));
+            rendererFrontend->queryRenderedFeatures(point, { layers, toFilter(env, jfilter) }));
 }
 
-jni::Array<jni::Object<geojson::Feature>> NativeMapView::queryRenderedFeaturesForBox(JNIEnv& env, jni::jfloat left, jni::jfloat top,
-                                                                            jni::jfloat right, jni::jfloat bottom, jni::Array<jni::String> layerIds,
-                                                                            jni::Array<jni::Object<>> jfilter) {
+jni::Local<jni::Array<jni::Object<geojson::Feature>>> NativeMapView::queryRenderedFeaturesForBox(JNIEnv& env, jni::jfloat left, jni::jfloat top,
+                                                                            jni::jfloat right, jni::jfloat bottom, const jni::Array<jni::String>& layerIds,
+                                                                            const jni::Array<jni::Object<>>& jfilter) {
     using namespace mbgl::android::conversion;
     using namespace mbgl::android::geojson;
 
     mbgl::optional<std::vector<std::string>> layers;
-    if (layerIds != nullptr && layerIds.Length(env) > 0) {
+    if (layerIds && layerIds.Length(env) > 0) {
         layers = toVector(env, layerIds);
     }
     mapbox::geometry::box<double> box = {
@@ -680,48 +680,48 @@ jni::Array<jni::Object<geojson::Feature>> NativeMapView::queryRenderedFeaturesFo
 
     return Feature::convert(
             env,
-            rendererFrontend->queryRenderedFeatures(box, { layers, toFilter(env, jni::SeizeLocal(env, std::move(jfilter))) }));
+            rendererFrontend->queryRenderedFeatures(box, { layers, toFilter(env, jfilter) }));
 }
 
-jni::Object<Light> NativeMapView::getLight(JNIEnv& env) {
+jni::Local<jni::Object<Light>> NativeMapView::getLight(JNIEnv& env) {
     mbgl::style::Light* light = map->getStyle().getLight();
     if (light) {
-        return jni::Object<Light>(Light::createJavaLightPeer(env, *map, *light));
+        return Light::createJavaLightPeer(env, *map, *light);
     } else {
-        return jni::Object<Light>();
+        return jni::Local<jni::Object<Light>>();
     }
 }
 
-jni::Array<jni::Object<Layer>> NativeMapView::getLayers(JNIEnv& env) {
+jni::Local<jni::Array<jni::Object<Layer>>> NativeMapView::getLayers(JNIEnv& env) {
 
     // Get the core layers
     std::vector<style::Layer*> layers = map->getStyle().getLayers();
 
     // Convert
-    jni::Array<jni::Object<Layer>> jLayers = jni::Array<jni::Object<Layer>>::New(env, layers.size());
+    auto jLayers = jni::Array<jni::Object<Layer>>::New(env, layers.size());
     int index = 0;
     for (auto layer : layers) {
-        jLayers.Set(env, index, *jni::SeizeLocal(env, jni::Object<Layer>(createJavaLayerPeer(env, *map, *layer))));
+        jLayers.Set(env, index, createJavaLayerPeer(env, *map, *layer));
         index++;
     }
 
     return jLayers;
 }
 
-jni::Object<Layer> NativeMapView::getLayer(JNIEnv& env, jni::String layerId) {
+jni::Local<jni::Object<Layer>> NativeMapView::getLayer(JNIEnv& env, const jni::String& layerId) {
 
     // Find the layer
     mbgl::style::Layer* coreLayer = map->getStyle().getLayer(jni::Make<std::string>(env, layerId));
     if (!coreLayer) {
        mbgl::Log::Debug(mbgl::Event::JNI, "No layer found");
-       return jni::Object<Layer>();
+       return jni::Local<jni::Object<Layer>>();
     }
 
     // Create and return the layer's native peer
-    return jni::Object<Layer>(createJavaLayerPeer(env, *map, *coreLayer));
+    return createJavaLayerPeer(env, *map, *coreLayer);
 }
 
-void NativeMapView::addLayer(JNIEnv& env, jlong nativeLayerPtr, jni::String before) {
+void NativeMapView::addLayer(JNIEnv& env, jlong nativeLayerPtr, const jni::String& before) {
     assert(nativeLayerPtr != 0);
 
     Layer *layer = reinterpret_cast<Layer *>(nativeLayerPtr);
@@ -732,7 +732,7 @@ void NativeMapView::addLayer(JNIEnv& env, jlong nativeLayerPtr, jni::String befo
     }
 }
 
-void NativeMapView::addLayerAbove(JNIEnv& env, jlong nativeLayerPtr, jni::String above) {
+void NativeMapView::addLayerAbove(JNIEnv& env, jlong nativeLayerPtr, const jni::String& above) {
     assert(nativeLayerPtr != 0);
 
     Layer *layer = reinterpret_cast<Layer *>(nativeLayerPtr);
@@ -795,33 +795,33 @@ void NativeMapView::addLayerAt(JNIEnv& env, jlong nativeLayerPtr, jni::jint inde
 /**
  * Remove by layer id.
  */
-jni::Object<Layer> NativeMapView::removeLayerById(JNIEnv& env, jni::String id) {
+jni::Local<jni::Object<Layer>> NativeMapView::removeLayerById(JNIEnv& env, const jni::String& id) {
     std::unique_ptr<mbgl::style::Layer> coreLayer = map->getStyle().removeLayer(jni::Make<std::string>(env, id));
     if (coreLayer) {
-        return jni::Object<Layer>(createJavaLayerPeer(env, *map, std::move(coreLayer)));
+        return createJavaLayerPeer(env, *map, std::move(coreLayer));
     } else {
-        return jni::Object<Layer>();
+        return jni::Local<jni::Object<Layer>>();
     }
 }
 
 /**
  * Remove layer at index.
  */
-jni::Object<Layer> NativeMapView::removeLayerAt(JNIEnv& env, jni::jint index) {
+jni::Local<jni::Object<Layer>> NativeMapView::removeLayerAt(JNIEnv& env, jni::jint index) {
     auto layers = map->getStyle().getLayers();
 
     // Check index
     int numLayers = layers.size() - 1;
     if (index > numLayers || index < 0) {
         Log::Warning(Event::JNI, "Index out of range: %i", index);
-        return jni::Object<Layer>();
+        return jni::Local<jni::Object<Layer>>();
     }
 
     std::unique_ptr<mbgl::style::Layer> coreLayer = map->getStyle().removeLayer(layers.at(index)->getID());
     if (coreLayer) {
-        return jni::Object<Layer>(createJavaLayerPeer(env, *map, std::move(coreLayer)));
+        return createJavaLayerPeer(env, *map, std::move(coreLayer));
     } else {
-        return jni::Object<Layer>();
+        return jni::Local<jni::Object<Layer>>();
     }
 }
 
@@ -838,12 +838,12 @@ void NativeMapView::removeLayer(JNIEnv&, jlong layerPtr) {
     }
 }
 
-jni::Array<jni::Object<Source>> NativeMapView::getSources(JNIEnv& env) {
+jni::Local<jni::Array<jni::Object<Source>>> NativeMapView::getSources(JNIEnv& env) {
     // Get the core sources
     std::vector<style::Source*> sources = map->getStyle().getSources();
 
     // Convert
-    jni::Array<jni::Object<Source>> jSources = jni::Array<jni::Object<Source>>::New(env, sources.size());
+    auto jSources = jni::Array<jni::Object<Source>>::New(env, sources.size());
     int index = 0;
     for (auto source : sources) {
         jSources.Set(env, index, Source::peerForCoreSource(env, *source, *rendererFrontend));
@@ -853,19 +853,19 @@ jni::Array<jni::Object<Source>> NativeMapView::getSources(JNIEnv& env) {
     return jSources;
 }
 
-jni::Object<Source> NativeMapView::getSource(JNIEnv& env, jni::String sourceId) {
+jni::Local<jni::Object<Source>> NativeMapView::getSource(JNIEnv& env, const jni::String& sourceId) {
     // Find the source
     mbgl::style::Source* coreSource = map->getStyle().getSource(jni::Make<std::string>(env, sourceId));
     if (!coreSource) {
        mbgl::Log::Debug(mbgl::Event::JNI, "No source found");
-       return jni::Object<Source>();
+       return jni::Local<jni::Object<Source>>();
     }
 
     // Create and return the source's native peer
-    return Source::peerForCoreSource(env, *coreSource, *rendererFrontend);
+    return jni::NewLocal(env, Source::peerForCoreSource(env, *coreSource, *rendererFrontend));
 }
 
-void NativeMapView::addSource(JNIEnv& env, jni::Object<Source> obj, jlong sourcePtr) {
+void NativeMapView::addSource(JNIEnv& env, const jni::Object<Source>& obj, jlong sourcePtr) {
     assert(sourcePtr != 0);
 
     Source *source = reinterpret_cast<Source *>(sourcePtr);
@@ -876,7 +876,7 @@ void NativeMapView::addSource(JNIEnv& env, jni::Object<Source> obj, jlong source
     }
 }
 
-void NativeMapView::removeSource(JNIEnv& env, jni::Object<Source> obj, jlong sourcePtr) {
+void NativeMapView::removeSource(JNIEnv& env, const jni::Object<Source>& obj, jlong sourcePtr) {
     assert(sourcePtr != 0);
 
     mbgl::android::Source *source = reinterpret_cast<mbgl::android::Source *>(sourcePtr);
@@ -885,7 +885,7 @@ void NativeMapView::removeSource(JNIEnv& env, jni::Object<Source> obj, jlong sou
     }
 }
 
-void NativeMapView::addImage(JNIEnv& env, jni::String name, jni::Object<Bitmap> bitmap, jni::jfloat scale, jni::jboolean sdf) {
+void NativeMapView::addImage(JNIEnv& env, const jni::String& name, const jni::Object<Bitmap>& bitmap, jni::jfloat scale, jni::jboolean sdf) {
     jni::NullCheck(env, &bitmap);
     mbgl::PremultipliedImage premultipliedImage = Bitmap::GetImage(env, bitmap);
 
@@ -897,26 +897,26 @@ void NativeMapView::addImage(JNIEnv& env, jni::String name, jni::Object<Bitmap>
     );
 }
 
-void NativeMapView::addImages(JNIEnv& env, jni::Array<jni::Object<mbgl::android::Image>> jimages) {
+void NativeMapView::addImages(JNIEnv& env, const jni::Array<jni::Object<mbgl::android::Image>>& jimages) {
     jni::NullCheck(env, &jimages);
     std::size_t len = jimages.Length(env);
 
     for (std::size_t i = 0; i < len; i++) {
-        auto image = mbgl::android::Image::getImage(env, *jni::SeizeLocal(env, jimages.Get(env, i)));
+        auto image = mbgl::android::Image::getImage(env, jimages.Get(env, i));
         map->getStyle().addImage(std::make_unique<mbgl::style::Image>(image));
     }
 }
 
-void NativeMapView::removeImage(JNIEnv& env, jni::String name) {
+void NativeMapView::removeImage(JNIEnv& env, const jni::String& name) {
     map->getStyle().removeImage(jni::Make<std::string>(env, name));
 }
 
-jni::Object<Bitmap> NativeMapView::getImage(JNIEnv& env, jni::String name) {
+jni::Local<jni::Object<Bitmap>> NativeMapView::getImage(JNIEnv& env, const jni::String& name) {
     const mbgl::style::Image *image = map->getStyle().getImage(jni::Make<std::string>(env, name));
     if (image) {
         return Bitmap::CreateBitmap(env, image->getImage());
     } else {
-        return jni::Object<Bitmap>();
+        return jni::Local<jni::Object<Bitmap>>();
     }
 }
 
@@ -936,13 +936,13 @@ mbgl::Map& NativeMapView::getMap() {
 
 void NativeMapView::registerNative(jni::JNIEnv& env) {
     // Lookup the class
-    static auto javaClass = jni::Class<NativeMapView>::Singleton(env);
+    static auto& javaClass = jni::Class<NativeMapView>::Singleton(env);
 
     #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
     // Register the peer
     jni::RegisterNativePeer<NativeMapView>(env, javaClass, "nativePtr",
-            std::make_unique<NativeMapView, JNIEnv&, jni::Object<NativeMapView>, jni::Object<FileSource>, jni::Object<MapRenderer>, jni::jfloat>,
+            jni::MakePeer<NativeMapView, const jni::Object<NativeMapView>&, const jni::Object<FileSource>&, const jni::Object<MapRenderer>&, jni::jfloat>,
             "nativeInitialize",
             "nativeDestroy",
             METHOD(&NativeMapView::resizeView, "nativeResizeView"),

platform/android/src/native_map_view.hpp

@@ -48,9 +48,9 @@ public:
     static void registerNative(jni::JNIEnv&);
 
     NativeMapView(jni::JNIEnv&,
-                  jni::Object<NativeMapView>,
-                  jni::Object<FileSource>,
-                  jni::Object<MapRenderer>,
+                  const jni::Object<NativeMapView>&,
+                  const jni::Object<FileSource>&,
+                  const jni::Object<MapRenderer>&,
                   jni::jfloat pixelRatio);
 
     virtual ~NativeMapView();
@@ -76,15 +76,15 @@ public:
 
     void resizeView(jni::JNIEnv&, int, int);
 
-    jni::String getStyleUrl(jni::JNIEnv&);
+    jni::Local<jni::String> getStyleUrl(jni::JNIEnv&);
 
-    void setStyleUrl(jni::JNIEnv&, jni::String);
+    void setStyleUrl(jni::JNIEnv&, const jni::String&);
 
-    jni::String getStyleJson(jni::JNIEnv&);
+    jni::Local<jni::String> getStyleJson(jni::JNIEnv&);
 
-    void setStyleJson(jni::JNIEnv&, jni::String);
+    void setStyleJson(jni::JNIEnv&, const jni::String&);
 
-    void setLatLngBounds(jni::JNIEnv&, jni::Object<mbgl::android::LatLngBounds>);
+    void setLatLngBounds(jni::JNIEnv&, const jni::Object<mbgl::android::LatLngBounds>&);
 
     void cancelTransitions(jni::JNIEnv&);
 
@@ -98,13 +98,13 @@ public:
 
     void flyTo(jni::JNIEnv&, jni::jdouble, jni::jdouble, jni::jdouble, jni::jlong, jni::jdouble, jni::jdouble);
 
-    jni::Object<LatLng> getLatLng(JNIEnv&);
+    jni::Local<jni::Object<LatLng>> getLatLng(JNIEnv&);
 
     void setLatLng(jni::JNIEnv&, jni::jdouble, jni::jdouble, jni::jlong);
 
-    jni::Object<CameraPosition> getCameraForLatLngBounds(jni::JNIEnv&, jni::Object<mbgl::android::LatLngBounds>, double top, double left, double bottom, double right, double bearing, double tilt);
+    jni::Local<jni::Object<CameraPosition>> getCameraForLatLngBounds(jni::JNIEnv&, const jni::Object<mbgl::android::LatLngBounds>&, double top, double left, double bottom, double right, double bearing, double tilt);
 
-    jni::Object<CameraPosition> getCameraForGeometry(jni::JNIEnv&, jni::Object<geojson::Geometry>, double top, double left, double bottom, double right, double bearing, double tilt);
+    jni::Local<jni::Object<CameraPosition>> getCameraForGeometry(jni::JNIEnv&, const jni::Object<geojson::Geometry>&, double top, double left, double bottom, double right, double bearing, double tilt);
 
     void setReachability(jni::JNIEnv&, jni::jboolean);
 
@@ -138,17 +138,17 @@ public:
 
     void resetNorth(jni::JNIEnv&);
 
-    void setVisibleCoordinateBounds(JNIEnv&, jni::Array<jni::Object<LatLng>>, jni::Object<RectF>, jni::jdouble, jni::jlong);
+    void setVisibleCoordinateBounds(JNIEnv&, const jni::Array<jni::Object<LatLng>>&, const jni::Object<RectF>&, jni::jdouble, jni::jlong);
 
     void setContentPadding(JNIEnv&, double, double, double, double);
 
     void scheduleSnapshot(jni::JNIEnv&);
 
-    jni::Object<CameraPosition> getCameraPosition(jni::JNIEnv&);
+    jni::Local<jni::Object<CameraPosition>> getCameraPosition(jni::JNIEnv&);
 
-    void updateMarker(jni::JNIEnv&, jni::jlong, jni::jdouble, jni::jdouble, jni::String);
+    void updateMarker(jni::JNIEnv&, jni::jlong, jni::jdouble, jni::jdouble, const jni::String&);
 
-    jni::Array<jni::jlong> addMarkers(jni::JNIEnv&, jni::Array<jni::Object<Marker>>);
+    jni::Local<jni::Array<jni::jlong>> addMarkers(jni::JNIEnv&, const jni::Array<jni::Object<Marker>>&);
 
     void onLowMemory(JNIEnv& env);
 
@@ -162,29 +162,29 @@ public:
 
     jni::jdouble getMetersPerPixelAtLatitude(JNIEnv&, jni::jdouble, jni::jdouble);
 
-    jni::Object<ProjectedMeters> projectedMetersForLatLng(JNIEnv&, jni::jdouble, jni::jdouble);
+    jni::Local<jni::Object<ProjectedMeters>> projectedMetersForLatLng(JNIEnv&, jni::jdouble, jni::jdouble);
 
-    jni::Object<PointF> pixelForLatLng(JNIEnv&, jdouble, jdouble);
+    jni::Local<jni::Object<PointF>> pixelForLatLng(JNIEnv&, jdouble, jdouble);
 
-    jni::Object<LatLng> latLngForProjectedMeters(JNIEnv&, jdouble, jdouble);
+    jni::Local<jni::Object<LatLng>> latLngForProjectedMeters(JNIEnv&, jdouble, jdouble);
 
-    jni::Object<LatLng> latLngForPixel(JNIEnv&, jfloat, jfloat);
+    jni::Local<jni::Object<LatLng>> latLngForPixel(JNIEnv&, jfloat, jfloat);
 
-    jni::Array<jlong> addPolylines(JNIEnv&, jni::Array<jni::Object<Polyline>>);
+    jni::Local<jni::Array<jlong>> addPolylines(JNIEnv&, const jni::Array<jni::Object<Polyline>>&);
 
-    jni::Array<jlong> addPolygons(JNIEnv&, jni::Array<jni::Object<Polygon>>);
+    jni::Local<jni::Array<jlong>> addPolygons(JNIEnv&, const jni::Array<jni::Object<Polygon>>&);
 
-    void updatePolyline(JNIEnv&, jlong, jni::Object<Polyline>);
+    void updatePolyline(JNIEnv&, jlong, const jni::Object<Polyline>&);
 
-    void updatePolygon(JNIEnv&, jlong, jni::Object<Polygon>);
+    void updatePolygon(JNIEnv&, jlong, const jni::Object<Polygon>&);
 
-    void removeAnnotations(JNIEnv&, jni::Array<jlong>);
+    void removeAnnotations(JNIEnv&, const jni::Array<jlong>&);
 
-    void addAnnotationIcon(JNIEnv&, jni::String, jint, jint, jfloat, jni::Array<jbyte>);
+    void addAnnotationIcon(JNIEnv&, const jni::String&, jint, jint, jfloat, const jni::Array<jbyte>&);
 
-    void removeAnnotationIcon(JNIEnv&, jni::String);
+    void removeAnnotationIcon(JNIEnv&, const jni::String&);
 
-    jni::jdouble getTopOffsetPixelsForAnnotationSymbol(JNIEnv&, jni::String);
+    jni::jdouble getTopOffsetPixelsForAnnotationSymbol(JNIEnv&, const jni::String&);
 
     jni::jlong getTransitionDuration(JNIEnv&);
 
@@ -194,53 +194,53 @@ public:
 
     void setTransitionDelay(JNIEnv&, jni::jlong);
 
-    jni::Array<jlong> queryPointAnnotations(JNIEnv&, jni::Object<RectF>);
+    jni::Local<jni::Array<jlong>> queryPointAnnotations(JNIEnv&, const jni::Object<RectF>&);
 
-    jni::Array<jlong> queryShapeAnnotations(JNIEnv&, jni::Object<RectF>);
+    jni::Local<jni::Array<jlong>> queryShapeAnnotations(JNIEnv&, const jni::Object<RectF>&);
 
-    jni::Array<jni::Object<geojson::Feature>> queryRenderedFeaturesForPoint(JNIEnv&, jni::jfloat, jni::jfloat,
-                                                                   jni::Array<jni::String>,
-                                                                   jni::Array<jni::Object<>> jfilter);
+    jni::Local<jni::Array<jni::Object<geojson::Feature>>> queryRenderedFeaturesForPoint(JNIEnv&, jni::jfloat, jni::jfloat,
+                                                                   const jni::Array<jni::String>&,
+                                                                   const jni::Array<jni::Object<>>& jfilter);
 
-    jni::Array<jni::Object<geojson::Feature>> queryRenderedFeaturesForBox(JNIEnv&, jni::jfloat, jni::jfloat, jni::jfloat,
-                                                                 jni::jfloat, jni::Array<jni::String>,
-                                                                 jni::Array<jni::Object<>> jfilter);
+    jni::Local<jni::Array<jni::Object<geojson::Feature>>> queryRenderedFeaturesForBox(JNIEnv&, jni::jfloat, jni::jfloat, jni::jfloat,
+                                                                 jni::jfloat, const jni::Array<jni::String>&,
+                                                                 const jni::Array<jni::Object<>>& jfilter);
 
-    jni::Object<Light> getLight(JNIEnv&);
+    jni::Local<jni::Object<Light>> getLight(JNIEnv&);
 
-    jni::Array<jni::Object<Layer>> getLayers(JNIEnv&);
+    jni::Local<jni::Array<jni::Object<Layer>>> getLayers(JNIEnv&);
 
-    jni::Object<Layer> getLayer(JNIEnv&, jni::String);
+    jni::Local<jni::Object<Layer>> getLayer(JNIEnv&, const jni::String&);
 
-    void addLayer(JNIEnv&, jlong, jni::String);
+    void addLayer(JNIEnv&, jlong, const jni::String&);
 
-    void addLayerAbove(JNIEnv&, jlong, jni::String);
+    void addLayerAbove(JNIEnv&, jlong, const jni::String&);
 
     void addLayerAt(JNIEnv&, jni::jlong, jni::jint);
 
-    jni::Object<Layer> removeLayerById(JNIEnv&, jni::String);
+    jni::Local<jni::Object<Layer>> removeLayerById(JNIEnv&, const jni::String&);
 
-    jni::Object<Layer> removeLayerAt(JNIEnv&, jni::jint);
+    jni::Local<jni::Object<Layer>> removeLayerAt(JNIEnv&, jni::jint);
 
     void removeLayer(JNIEnv&, jlong);
 
-    jni::Array<jni::Object<Source>> getSources(JNIEnv&);
+    jni::Local<jni::Array<jni::Object<Source>>> getSources(JNIEnv&);
 
-    jni::Object<Source> getSource(JNIEnv&, jni::String);
+    jni::Local<jni::Object<Source>> getSource(JNIEnv&, const jni::String&);
 
-    void addSource(JNIEnv&, jni::Object<Source>, jlong nativePtr);
+    void addSource(JNIEnv&, const jni::Object<Source>&, jlong nativePtr);
 
-    jni::Object<Source> removeSourceById(JNIEnv&, jni::String);
+    jni::Local<jni::Object<Source>> removeSourceById(JNIEnv&, const jni::String&);
 
-    void removeSource(JNIEnv&, jni::Object<Source>, jlong nativePtr);
+    void removeSource(JNIEnv&, const jni::Object<Source>&, jlong nativePtr);
 
-    void addImage(JNIEnv&, jni::String, jni::Object<Bitmap> bitmap, jni::jfloat, jni::jboolean);
+    void addImage(JNIEnv&, const jni::String&, const jni::Object<Bitmap>& bitmap, jni::jfloat, jni::jboolean);
 
-    void addImages(JNIEnv&, jni::Array<jni::Object<mbgl::android::Image>>);
+    void addImages(JNIEnv&, const jni::Array<jni::Object<mbgl::android::Image>>&);
 
-    void removeImage(JNIEnv&, jni::String);
+    void removeImage(JNIEnv&, const jni::String&);
 
-    jni::Object<Bitmap> getImage(JNIEnv&, jni::String);
+    jni::Local<jni::Object<Bitmap>> getImage(JNIEnv&, const jni::String&);
 
     void setPrefetchesTiles(JNIEnv&, jni::jboolean);
 
@@ -252,7 +252,7 @@ private:
     std::unique_ptr<AndroidRendererFrontend> rendererFrontend;
 
     JavaVM *vm = nullptr;
-    jni::Weak<jni::Object<NativeMapView>> javaPeer;
+    jni::WeakReference<jni::Object<NativeMapView>> javaPeer;
 
     MapRenderer& mapRenderer;
 

platform/android/src/offline/offline_manager.cpp

@@ -3,14 +3,13 @@
 #include <mbgl/util/string.hpp>
 
 #include "../attach_env.hpp"
-#include "../jni/generic_global_ref_deleter.hpp"
 
 namespace mbgl {
 namespace android {
 
 // OfflineManager //
 
-OfflineManager::OfflineManager(jni::JNIEnv& env, jni::Object<FileSource> jFileSource)
+OfflineManager::OfflineManager(jni::JNIEnv& env, const jni::Object<FileSource>& jFileSource)
     : fileSource(mbgl::android::FileSource::getDefaultFileSource(env, jFileSource)) {
 }
 
@@ -20,12 +19,14 @@ void OfflineManager::setOfflineMapboxTileCountLimit(jni::JNIEnv&, jni::jlong lim
     fileSource.setOfflineMapboxTileCountLimit(limit);
 }
 
-void OfflineManager::listOfflineRegions(jni::JNIEnv& env_, jni::Object<FileSource> jFileSource_, jni::Object<ListOfflineRegionsCallback> callback_) {
-    // list regions
+void OfflineManager::listOfflineRegions(jni::JNIEnv& env_, const jni::Object<FileSource>& jFileSource_, const jni::Object<ListOfflineRegionsCallback>& callback_) {
+    auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
+    auto globalFilesource = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, jFileSource_);
+
     fileSource.listOfflineRegions([
         //Keep a shared ptr to a global reference of the callback and file source so they are not GC'd in the meanwhile
-        callback = std::shared_ptr<jni::jobject>(callback_.NewGlobalRef(env_).release().Get(), GenericGlobalRefDeleter()),
-        jFileSource = std::shared_ptr<jni::jobject>(jFileSource_.NewGlobalRef(env_).release().Get(), GenericGlobalRefDeleter())
+        callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback)),
+        jFileSource = std::make_shared<decltype(globalFilesource)>(std::move(globalFilesource))
     ](mbgl::expected<mbgl::OfflineRegions, std::exception_ptr> regions) mutable {
 
         // Reattach, the callback comes from a different thread
@@ -33,20 +34,19 @@ void OfflineManager::listOfflineRegions(jni::JNIEnv& env_, jni::Object<FileSourc
 
         if (regions) {
             OfflineManager::ListOfflineRegionsCallback::onList(
-                *env, jni::Object<FileSource>(*jFileSource),
-                jni::Object<ListOfflineRegionsCallback>(*callback), std::move(*regions));
+                *env, *jFileSource, *callback, std::move(*regions));
         } else {
             OfflineManager::ListOfflineRegionsCallback::onError(
-                *env, jni::Object<ListOfflineRegionsCallback>(*callback), regions.error());
+                *env, *callback, regions.error());
         }
     });
 }
 
 void OfflineManager::createOfflineRegion(jni::JNIEnv& env_,
-                                         jni::Object<FileSource> jFileSource_,
-                                         jni::Object<OfflineRegionDefinition> definition_,
-                                         jni::Array<jni::jbyte> metadata_,
-                                         jni::Object<CreateOfflineRegionCallback> callback_) {
+                                         const jni::Object<FileSource>& jFileSource_,
+                                         const jni::Object<OfflineRegionDefinition>& definition_,
+                                         const jni::Array<jni::jbyte>& metadata_,
+                                         const jni::Object<CreateOfflineRegionCallback>& callback_) {
     // Convert
     auto definition = OfflineRegionDefinition::getDefinition(env_, definition_);
 
@@ -55,11 +55,14 @@ void OfflineManager::createOfflineRegion(jni::JNIEnv& env_,
         metadata = OfflineRegion::metadata(env_, metadata_);
     }
 
+    auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
+    auto globalFilesource = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, jFileSource_);
+
     // Create region
     fileSource.createOfflineRegion(definition, metadata, [
         //Keep a shared ptr to a global reference of the callback and file source so they are not GC'd in the meanwhile
-        callback = std::shared_ptr<jni::jobject>(callback_.NewGlobalRef(env_).release().Get(), GenericGlobalRefDeleter()),
-        jFileSource = std::shared_ptr<jni::jobject>(jFileSource_.NewGlobalRef(env_).release().Get(), GenericGlobalRefDeleter())
+        callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback)),
+        jFileSource = std::make_shared<decltype(globalFilesource)>(std::move(globalFilesource))
     ](mbgl::expected<mbgl::OfflineRegion, std::exception_ptr> region) mutable {
 
         // Reattach, the callback comes from a different thread
@@ -67,12 +70,11 @@ void OfflineManager::createOfflineRegion(jni::JNIEnv& env_,
 
         if (region) {
             OfflineManager::CreateOfflineRegionCallback::onCreate(
-                *env,
-                jni::Object<FileSource>(*jFileSource),
-                jni::Object<CreateOfflineRegionCallback>(*callback), std::move(*region)
+                *env, *jFileSource, *callback, std::move(*region)
             );
         } else {
-            OfflineManager::CreateOfflineRegionCallback::onError(*env, jni::Object<CreateOfflineRegionCallback>(*callback), region.error());
+            OfflineManager::CreateOfflineRegionCallback::onError(
+                *env, *callback, region.error());
         }
     });
 }
@@ -81,12 +83,12 @@ void OfflineManager::registerNative(jni::JNIEnv& env) {
     jni::Class<ListOfflineRegionsCallback>::Singleton(env);
     jni::Class<CreateOfflineRegionCallback>::Singleton(env);
 
-    static auto javaClass = jni::Class<OfflineManager>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineManager>::Singleton(env);
 
     #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
     jni::RegisterNativePeer<OfflineManager>( env, javaClass, "nativePtr",
-        std::make_unique<OfflineManager, JNIEnv&, jni::Object<FileSource>>,
+        jni::MakePeer<OfflineManager, const jni::Object<FileSource>&>,
         "initialize",
         "finalize",
         METHOD(&OfflineManager::setOfflineMapboxTileCountLimit, "setOfflineMapboxTileCountLimit"),
@@ -97,53 +99,50 @@ void OfflineManager::registerNative(jni::JNIEnv& env) {
 // OfflineManager::ListOfflineRegionsCallback //
 
 void OfflineManager::ListOfflineRegionsCallback::onError(jni::JNIEnv& env,
-                                                          jni::Object<OfflineManager::ListOfflineRegionsCallback> callback,
+                                                          const jni::Object<OfflineManager::ListOfflineRegionsCallback>& callback,
                                                           std::exception_ptr error) {
-    static auto javaClass = jni::Class<OfflineManager::ListOfflineRegionsCallback>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineManager::ListOfflineRegionsCallback>::Singleton(env);
     static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
 
-    callback.Call(env, method,
-        *jni::SeizeLocal(env, jni::Make<jni::String>(env, mbgl::util::toString(error))));
+    callback.Call(env, method, jni::Make<jni::String>(env, mbgl::util::toString(error)));
 }
 
 void OfflineManager::ListOfflineRegionsCallback::onList(jni::JNIEnv& env,
-                                                        jni::Object<FileSource> jFileSource,
-                                                        jni::Object<OfflineManager::ListOfflineRegionsCallback> callback,
+                                                        const jni::Object<FileSource>& jFileSource,
+                                                        const jni::Object<OfflineManager::ListOfflineRegionsCallback>& callback,
                                                         mbgl::optional<std::vector<mbgl::OfflineRegion>> regions) {
-    static auto javaClass = jni::Class<OfflineManager::ListOfflineRegionsCallback>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineManager::ListOfflineRegionsCallback>::Singleton(env);
     static auto method = javaClass.GetMethod<void (jni::Array<jni::Object<OfflineRegion>>)>(env, "onList");
 
     std::size_t index = 0;
-    auto jregions = jni::SeizeLocal(env, jni::Array<jni::Object<OfflineRegion>>::New(env, regions->size()));
+    auto jregions = jni::Array<jni::Object<OfflineRegion>>::New(env, regions->size());
     for (auto& region : *regions) {
-        jregions->Set(env, index, *jni::SeizeLocal(env, OfflineRegion::New(env, jFileSource, std::move(region))));
+        jregions.Set(env, index, OfflineRegion::New(env, jFileSource, std::move(region)));
         index++;
     }
 
-    callback.Call(env, method, *jregions);
+    callback.Call(env, method, jregions);
 }
 
 // OfflineManager::CreateOfflineRegionCallback //
 
 void OfflineManager::CreateOfflineRegionCallback::onError(jni::JNIEnv& env,
-                                                          jni::Object<OfflineManager::CreateOfflineRegionCallback> callback,
+                                                          const jni::Object<OfflineManager::CreateOfflineRegionCallback>& callback,
                                                           std::exception_ptr error) {
-    static auto javaClass = jni::Class<OfflineManager::CreateOfflineRegionCallback>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineManager::CreateOfflineRegionCallback>::Singleton(env);
     static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
 
-    callback.Call(env, method,
-        *jni::SeizeLocal(env, jni::Make<jni::String>(env, mbgl::util::toString(error))));
+    callback.Call(env, method, jni::Make<jni::String>(env, mbgl::util::toString(error)));
 }
 
 void OfflineManager::CreateOfflineRegionCallback::onCreate(jni::JNIEnv& env,
-                                                        jni::Object<FileSource> jFileSource,
-                                                        jni::Object<OfflineManager::CreateOfflineRegionCallback> callback,
+                                                        const jni::Object<FileSource>& jFileSource,
+                                                        const jni::Object<OfflineManager::CreateOfflineRegionCallback>& callback,
                                                         mbgl::optional<mbgl::OfflineRegion> region) {
-    static auto javaClass = jni::Class<OfflineManager::CreateOfflineRegionCallback>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineManager::CreateOfflineRegionCallback>::Singleton(env);
     static auto method = javaClass.GetMethod<void (jni::Object<OfflineRegion>)>(env, "onCreate");
 
-    callback.Call(env, method,
-        *jni::SeizeLocal(env, OfflineRegion::New(env, jFileSource, std::move(*region))));
+    callback.Call(env, method, OfflineRegion::New(env, jFileSource, std::move(*region)));
 }
 
 } // namespace android

platform/android/src/offline/offline_manager.hpp

@@ -20,11 +20,11 @@ public:
     public:
         static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineManager$ListOfflineRegionsCallback";}
 
-        static void onError(jni::JNIEnv&, jni::Object<OfflineManager::ListOfflineRegionsCallback>, std::exception_ptr);
+        static void onError(jni::JNIEnv&, const jni::Object<OfflineManager::ListOfflineRegionsCallback>&, std::exception_ptr);
 
         static void onList(jni::JNIEnv&,
-                            jni::Object<FileSource>,
-                            jni::Object<OfflineManager::ListOfflineRegionsCallback>,
+                            const jni::Object<FileSource>&,
+                            const jni::Object<OfflineManager::ListOfflineRegionsCallback>&,
                             mbgl::optional<std::vector<mbgl::OfflineRegion>>);
     };
 
@@ -32,11 +32,11 @@ public:
     public:
         static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineManager$CreateOfflineRegionCallback"; }
 
-        static void onError(jni::JNIEnv&, jni::Object<OfflineManager::CreateOfflineRegionCallback>, std::exception_ptr);
+        static void onError(jni::JNIEnv&, const jni::Object<OfflineManager::CreateOfflineRegionCallback>&, std::exception_ptr);
 
         static void onCreate(jni::JNIEnv&,
-                            jni::Object<FileSource>,
-                            jni::Object<OfflineManager::CreateOfflineRegionCallback>,
+                            const jni::Object<FileSource>&,
+                            const jni::Object<OfflineManager::CreateOfflineRegionCallback>&,
                             mbgl::optional<mbgl::OfflineRegion>);
     };
 
@@ -44,18 +44,18 @@ public:
 
     static void registerNative(jni::JNIEnv&);
 
-    OfflineManager(jni::JNIEnv&, jni::Object<FileSource>);
+    OfflineManager(jni::JNIEnv&, const jni::Object<FileSource>&);
     ~OfflineManager();
 
     void setOfflineMapboxTileCountLimit(jni::JNIEnv&, jni::jlong limit);
 
-    void listOfflineRegions(jni::JNIEnv&, jni::Object<FileSource>, jni::Object<ListOfflineRegionsCallback> callback);
+    void listOfflineRegions(jni::JNIEnv&, const jni::Object<FileSource>&, const jni::Object<ListOfflineRegionsCallback>& callback);
 
     void createOfflineRegion(jni::JNIEnv&,
-                             jni::Object<FileSource> jFileSource_,
-                             jni::Object<OfflineRegionDefinition> definition,
-                             jni::Array<jni::jbyte> metadata,
-                             jni::Object<OfflineManager::CreateOfflineRegionCallback> callback);
+                             const jni::Object<FileSource>& jFileSource_,
+                             const jni::Object<OfflineRegionDefinition>& definition,
+                             const jni::Array<jni::jbyte>& metadata,
+                             const jni::Object<OfflineManager::CreateOfflineRegionCallback>& callback);
 
 private:
     mbgl::DefaultFileSource& fileSource;

platform/android/src/offline/offline_region.cpp

@@ -7,71 +7,62 @@
 #include "offline_region_error.hpp"
 #include "offline_region_status.hpp"
 #include "../attach_env.hpp"
-#include "../jni/generic_global_ref_deleter.hpp"
 
 namespace mbgl {
 namespace android {
 
 // OfflineRegion //
 
-OfflineRegion::OfflineRegion(jni::JNIEnv& env, jni::jlong offlineRegionPtr, jni::Object<FileSource> jFileSource)
+OfflineRegion::OfflineRegion(jni::JNIEnv& env, jni::jlong offlineRegionPtr, const jni::Object<FileSource>& jFileSource)
     : region(reinterpret_cast<mbgl::OfflineRegion *>(offlineRegionPtr)),
       fileSource(mbgl::android::FileSource::getDefaultFileSource(env, jFileSource)) {}
 
 OfflineRegion::~OfflineRegion() {}
 
-void OfflineRegion::setOfflineRegionObserver(jni::JNIEnv& env_, jni::Object<OfflineRegion::OfflineRegionObserver> callback) {
+void OfflineRegion::setOfflineRegionObserver(jni::JNIEnv& env_, const jni::Object<OfflineRegion::OfflineRegionObserver>& callback) {
 
     // Define the observer
     class Observer : public mbgl::OfflineRegionObserver {
     public:
-        Observer(jni::Global<jni::Object<OfflineRegion::OfflineRegionObserver>>&& callback_)
-            //TODO add a generic deleter for jni::Object
-            : callback(callback_.release().Get()) {
-        }
-
-        ~Observer() override {
-            android::UniqueEnv env = android::AttachEnv();
-            env->DeleteGlobalRef(Unwrap(*callback));
+        Observer(jni::Global<jni::Object<OfflineRegion::OfflineRegionObserver>, jni::EnvAttachingDeleter> callback_)
+            : callback(std::move(callback_)) {
         }
 
         void statusChanged(mbgl::OfflineRegionStatus status) override {
             // Reattach, the callback comes from a different thread
             android::UniqueEnv env = android::AttachEnv();
 
-            static auto javaClass = jni::Class<OfflineRegion::OfflineRegionObserver>::Singleton(*env);
+            static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionObserver>::Singleton(*env);
             static auto method = javaClass.GetMethod<void (jni::Object<OfflineRegionStatus>)>(*env, "onStatusChanged");
 
-            callback.Call(*env, method,
-                *jni::SeizeLocal(*env, OfflineRegionStatus::New(*env, status)));
+            callback.Call(*env, method, OfflineRegionStatus::New(*env, status));
         }
 
         void responseError(mbgl::Response::Error error) override {
             // Reattach, the callback comes from a different thread
             android::UniqueEnv env = android::AttachEnv();
 
-            static auto javaClass = jni::Class<OfflineRegion::OfflineRegionObserver>::Singleton(*env);
+            static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionObserver>::Singleton(*env);
             static auto method = javaClass.GetMethod<void (jni::Object<mbgl::android::OfflineRegionError>)>(*env, "onError");
 
-            callback.Call(*env, method,
-                *jni::SeizeLocal(*env, OfflineRegionError::New(*env, error)));
+            callback.Call(*env, method, OfflineRegionError::New(*env, error));
         }
 
         void mapboxTileCountLimitExceeded(uint64_t limit) override {
             // Reattach, the callback comes from a different thread
             android::UniqueEnv env = android::AttachEnv();
 
-            static auto javaClass = jni::Class<OfflineRegion::OfflineRegionObserver>::Singleton(*env);
+            static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionObserver>::Singleton(*env);
             static auto method = javaClass.GetMethod<void (jni::jlong)>(*env, "mapboxTileCountLimitExceeded");
 
             callback.Call(*env, method, jlong(limit));
         }
 
-        jni::Object<OfflineRegion::OfflineRegionObserver> callback;
+        jni::Global<jni::Object<OfflineRegion::OfflineRegionObserver>, jni::EnvAttachingDeleter> callback;
     };
 
     // Set the observer
-    fileSource.setOfflineRegionObserver(*region, std::make_unique<Observer>(callback.NewGlobalRef(env_)));
+    fileSource.setOfflineRegionObserver(*region, std::make_unique<Observer>(jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback)));
 }
 
 void OfflineRegion::setOfflineRegionDownloadState(jni::JNIEnv&, jni::jint jState) {
@@ -92,85 +83,84 @@ void OfflineRegion::setOfflineRegionDownloadState(jni::JNIEnv&, jni::jint jState
     fileSource.setOfflineRegionDownloadState(*region, state);
 }
 
-void OfflineRegion::getOfflineRegionStatus(jni::JNIEnv& env_, jni::Object<OfflineRegionStatusCallback> callback_) {
+void OfflineRegion::getOfflineRegionStatus(jni::JNIEnv& env_, const jni::Object<OfflineRegionStatusCallback>& callback_) {
+    auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
 
     fileSource.getOfflineRegionStatus(*region, [
         //Ensure the object is not gc'd in the meanwhile
-        callback = std::shared_ptr<jni::jobject>(callback_.NewGlobalRef(env_).release().Get(), GenericGlobalRefDeleter())
+        callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))
     ](mbgl::expected<mbgl::OfflineRegionStatus, std::exception_ptr> status) mutable {
         // Reattach, the callback comes from a different thread
         android::UniqueEnv env = android::AttachEnv();
 
         if (status) {
-            OfflineRegionStatusCallback::onStatus(*env, jni::Object<OfflineRegionStatusCallback>(*callback), std::move(*status));
+            OfflineRegionStatusCallback::onStatus(*env, *callback, std::move(*status));
         } else {
-            OfflineRegionStatusCallback::onError(*env, jni::Object<OfflineRegionStatusCallback>(*callback), status.error());
+            OfflineRegionStatusCallback::onError(*env, *callback, status.error());
         }
     });
 }
 
-void OfflineRegion::deleteOfflineRegion(jni::JNIEnv& env_, jni::Object<OfflineRegionDeleteCallback> callback_) {
-    // Delete
+void OfflineRegion::deleteOfflineRegion(jni::JNIEnv& env_, const jni::Object<OfflineRegionDeleteCallback>& callback_) {
+    auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
+
     fileSource.deleteOfflineRegion(std::move(*region), [
         //Ensure the object is not gc'd in the meanwhile
-        callback = std::shared_ptr<jni::jobject>(callback_.NewGlobalRef(env_).release().Get(), GenericGlobalRefDeleter())
+        callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))
     ](std::exception_ptr error) mutable {
         // Reattach, the callback comes from a different thread
         android::UniqueEnv env = android::AttachEnv();
 
         if (error) {
-            OfflineRegionDeleteCallback::onError(*env, jni::Object<OfflineRegionDeleteCallback>(*callback), error);
+            OfflineRegionDeleteCallback::onError(*env, *callback, error);
         } else {
-            OfflineRegionDeleteCallback::onDelete(*env, jni::Object<OfflineRegionDeleteCallback>(*callback));
+            OfflineRegionDeleteCallback::onDelete(*env, *callback);
         }
     });
 }
 
-void OfflineRegion::updateOfflineRegionMetadata(jni::JNIEnv& env_, jni::Array<jni::jbyte> jMetadata, jni::Object<OfflineRegionUpdateMetadataCallback> callback_) {
-
-    // Convert
+void OfflineRegion::updateOfflineRegionMetadata(jni::JNIEnv& env_, const jni::Array<jni::jbyte>& jMetadata, const jni::Object<OfflineRegionUpdateMetadataCallback>& callback_) {
     auto metadata = OfflineRegion::metadata(env_, jMetadata);
+    auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
 
     fileSource.updateOfflineMetadata(region->getID(), metadata, [
         //Ensure the object is not gc'd in the meanwhile
-        callback = std::shared_ptr<jni::jobject>(callback_.NewGlobalRef(env_).release().Get(), GenericGlobalRefDeleter())
+        callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))
     ](mbgl::expected<mbgl::OfflineRegionMetadata, std::exception_ptr> data) mutable {
         // Reattach, the callback comes from a different thread
         android::UniqueEnv env = android::AttachEnv();
 
         if (data) {
-            OfflineRegionUpdateMetadataCallback::onUpdate(*env, jni::Object<OfflineRegionUpdateMetadataCallback>(*callback), std::move(*data));
+            OfflineRegionUpdateMetadataCallback::onUpdate(*env, *callback, std::move(*data));
         } else {
-            OfflineRegionUpdateMetadataCallback::onError(*env, jni::Object<OfflineRegionUpdateMetadataCallback>(*callback), data.error());
+            OfflineRegionUpdateMetadataCallback::onError(*env, *callback, data.error());
         }
     });
 }
 
-jni::Object<OfflineRegion> OfflineRegion::New(jni::JNIEnv& env, jni::Object<FileSource> jFileSource, mbgl::OfflineRegion region) {
+jni::Local<jni::Object<OfflineRegion>> OfflineRegion::New(jni::JNIEnv& env, const jni::Object<FileSource>& jFileSource, mbgl::OfflineRegion region) {
 
     // Definition
-    auto definition = jni::SeizeLocal(env, region.getDefinition().match(
+    auto definition = region.getDefinition().match(
             [&](const mbgl::OfflineTilePyramidRegionDefinition def) {
-                return jni::Object<OfflineRegionDefinition>(
-                        *OfflineTilePyramidRegionDefinition::New(env, def));
+                return OfflineTilePyramidRegionDefinition::New(env, def);
             }, [&](const mbgl::OfflineGeometryRegionDefinition def) {
-                return jni::Object<OfflineRegionDefinition>(
-                        *OfflineGeometryRegionDefinition::New(env, def));
-            }));
+                return OfflineGeometryRegionDefinition::New(env, def);
+            });
 
     // Create region java object
-    static auto javaClass = jni::Class<OfflineRegion>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineRegion>::Singleton(env);
     static auto constructor = javaClass.GetConstructor<jni::jlong, jni::Object<FileSource>, jni::jlong, jni::Object<OfflineRegionDefinition>, jni::Array<jni::jbyte>>(env);
 
     return javaClass.New(env, constructor,
         reinterpret_cast<jni::jlong>(new mbgl::OfflineRegion(std::move(region))), //Copy a region to the heap
         jFileSource,
         jni::jlong(region.getID()),
-        *definition,
-        *jni::SeizeLocal(env, OfflineRegion::metadata(env, region.getMetadata())));
+        definition,
+        OfflineRegion::metadata(env, region.getMetadata()));
 }
 
-jni::Array<jni::jbyte> OfflineRegion::metadata(jni::JNIEnv& env, mbgl::OfflineRegionMetadata metadata_) {
+jni::Local<jni::Array<jni::jbyte>> OfflineRegion::metadata(jni::JNIEnv& env, mbgl::OfflineRegionMetadata metadata_) {
     std::vector<jni::jbyte> convertedMetadata(metadata_.begin(), metadata_.end());
     std::size_t length = static_cast<std::size_t>(convertedMetadata.size());
     auto metadata = jni::Array<jni::jbyte>::New(env, length);
@@ -178,7 +168,7 @@ jni::Array<jni::jbyte> OfflineRegion::metadata(jni::JNIEnv& env, mbgl::OfflineRe
     return metadata;
 }
 
-mbgl::OfflineRegionMetadata OfflineRegion::metadata(jni::JNIEnv& env, jni::Array<jni::jbyte> metadata_) {
+mbgl::OfflineRegionMetadata OfflineRegion::metadata(jni::JNIEnv& env, const jni::Array<jni::jbyte>& metadata_) {
     std::size_t length = metadata_.Length(env);
     auto metadata_tmp = std::vector<jni::jbyte>();
     metadata_tmp.resize(length);
@@ -193,12 +183,12 @@ void OfflineRegion::registerNative(jni::JNIEnv& env) {
     jni::Class<OfflineRegionDeleteCallback>::Singleton(env);
     jni::Class<OfflineRegionUpdateMetadataCallback>::Singleton(env);
 
-    static auto javaClass = jni::Class<OfflineRegion>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineRegion>::Singleton(env);
 
     #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
     jni::RegisterNativePeer<OfflineRegion>( env, javaClass, "nativePtr",
-        std::make_unique<OfflineRegion, JNIEnv&, jni::jlong, jni::Object<FileSource>>,
+        jni::MakePeer<OfflineRegion, jni::jlong, const jni::Object<FileSource>&>,
         "initialize",
         "finalize",
         METHOD(&OfflineRegion::setOfflineRegionObserver, "setOfflineRegionObserver"),
@@ -214,40 +204,37 @@ void OfflineRegion::registerNative(jni::JNIEnv& env) {
 // OfflineRegionStatusCallback //
 
 void OfflineRegion::OfflineRegionStatusCallback::onError(jni::JNIEnv& env,
-                                                          jni::Object<OfflineRegion::OfflineRegionStatusCallback> callback,
+                                                          const jni::Object<OfflineRegion::OfflineRegionStatusCallback>& callback,
                                                           std::exception_ptr error) {
-    static auto javaClass = jni::Class<OfflineRegion::OfflineRegionStatusCallback>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionStatusCallback>::Singleton(env);
     static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
 
-    callback.Call(env, method,
-        *jni::SeizeLocal(env, jni::Make<jni::String>(env, mbgl::util::toString(error))));
+    callback.Call(env, method, jni::Make<jni::String>(env, mbgl::util::toString(error)));
 }
 
 void OfflineRegion::OfflineRegionStatusCallback::onStatus(jni::JNIEnv& env,
-                                                        jni::Object<OfflineRegion::OfflineRegionStatusCallback> callback,
+                                                        const jni::Object<OfflineRegion::OfflineRegionStatusCallback>& callback,
                                                         mbgl::optional<mbgl::OfflineRegionStatus> status) {
-    static auto javaClass = jni::Class<OfflineRegion::OfflineRegionStatusCallback>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionStatusCallback>::Singleton(env);
     static auto method = javaClass.GetMethod<void (jni::Object<OfflineRegionStatus>)>(env, "onStatus");
 
-    callback.Call(env, method,
-        *jni::SeizeLocal(env, OfflineRegionStatus::New(env, std::move(*status))));
+    callback.Call(env, method, OfflineRegionStatus::New(env, std::move(*status)));
 }
 
 // OfflineRegionDeleteCallback //
 
 void OfflineRegion::OfflineRegionDeleteCallback::onError(jni::JNIEnv& env,
-                                                          jni::Object<OfflineRegion::OfflineRegionDeleteCallback> callback,
+                                                          const jni::Object<OfflineRegion::OfflineRegionDeleteCallback>& callback,
                                                           std::exception_ptr error) {
-    static auto javaClass = jni::Class<OfflineRegion::OfflineRegionDeleteCallback>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionDeleteCallback>::Singleton(env);
     static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
 
-    callback.Call(env, method,
-        *jni::SeizeLocal(env, jni::Make<jni::String>(env, mbgl::util::toString(error))));
+    callback.Call(env, method, jni::Make<jni::String>(env, mbgl::util::toString(error)));
 }
 
-void OfflineRegion::OfflineRegionDeleteCallback::onDelete(jni::JNIEnv& env, jni::Object<OfflineRegion::OfflineRegionDeleteCallback> callback) {
+void OfflineRegion::OfflineRegionDeleteCallback::onDelete(jni::JNIEnv& env, const jni::Object<OfflineRegion::OfflineRegionDeleteCallback>& callback) {
     // Trigger callback
-    static auto javaClass = jni::Class<OfflineRegion::OfflineRegionDeleteCallback>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionDeleteCallback>::Singleton(env);
     static auto method = javaClass.GetMethod<void ()>(env, "onDelete");
 
     callback.Call(env, method);
@@ -256,23 +243,21 @@ void OfflineRegion::OfflineRegionDeleteCallback::onDelete(jni::JNIEnv& env, jni:
 // OfflineRegionUpdateMetadataCallback //
 
 void OfflineRegion::OfflineRegionUpdateMetadataCallback::onError(jni::JNIEnv& env,
-                                                          jni::Object<OfflineRegion::OfflineRegionUpdateMetadataCallback> callback,
+                                                          const jni::Object<OfflineRegion::OfflineRegionUpdateMetadataCallback>& callback,
                                                           std::exception_ptr error) {
-    static auto javaClass = jni::Class<OfflineRegion::OfflineRegionUpdateMetadataCallback>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionUpdateMetadataCallback>::Singleton(env);
     static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
 
-    callback.Call(env, method,
-        *jni::SeizeLocal(env, jni::Make<jni::String>(env, mbgl::util::toString(error))));
+    callback.Call(env, method, jni::Make<jni::String>(env, mbgl::util::toString(error)));
 }
 
 void OfflineRegion::OfflineRegionUpdateMetadataCallback::onUpdate(jni::JNIEnv& env,
-                                                        jni::Object<OfflineRegion::OfflineRegionUpdateMetadataCallback> callback,
+                                                        const jni::Object<OfflineRegion::OfflineRegionUpdateMetadataCallback>& callback,
                                                         mbgl::optional<mbgl::OfflineRegionMetadata> metadata) {
-    static auto javaClass = jni::Class<OfflineRegion::OfflineRegionUpdateMetadataCallback>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionUpdateMetadataCallback>::Singleton(env);
     static auto method = javaClass.GetMethod<void (jni::Array<jni::jbyte>)>(env, "onUpdate");
 
-    callback.Call(env, method,
-        *jni::SeizeLocal(env, OfflineRegion::metadata(env, std::move(*metadata))));
+    callback.Call(env, method, OfflineRegion::metadata(env, std::move(*metadata)));
 }
 
 } // namespace android

platform/android/src/offline/offline_region.hpp

@@ -21,10 +21,10 @@ public:
     public:
         static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegion$OfflineRegionStatusCallback"; };
 
-        static void onError(jni::JNIEnv&, jni::Object<OfflineRegionStatusCallback>, std::exception_ptr);
+        static void onError(jni::JNIEnv&, const jni::Object<OfflineRegionStatusCallback>&, std::exception_ptr);
 
         static void onStatus(jni::JNIEnv&,
-                            jni::Object<OfflineRegionStatusCallback>,
+                            const jni::Object<OfflineRegionStatusCallback>&,
                             mbgl::optional<mbgl::OfflineRegionStatus>);
     };
 
@@ -32,43 +32,43 @@ public:
     public:
         static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegion$OfflineRegionDeleteCallback"; };
 
-        static void onError(jni::JNIEnv&, jni::Object<OfflineRegionDeleteCallback>, std::exception_ptr);
+        static void onError(jni::JNIEnv&, const jni::Object<OfflineRegionDeleteCallback>&, std::exception_ptr);
 
-        static void onDelete(jni::JNIEnv&, jni::Object<OfflineRegionDeleteCallback>);
+        static void onDelete(jni::JNIEnv&, const jni::Object<OfflineRegionDeleteCallback>&);
     };
 
     class OfflineRegionUpdateMetadataCallback {
     public:
         static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegion$OfflineRegionUpdateMetadataCallback"; };
 
-        static void onError(jni::JNIEnv&, jni::Object<OfflineRegionUpdateMetadataCallback>, std::exception_ptr);
+        static void onError(jni::JNIEnv&, const jni::Object<OfflineRegionUpdateMetadataCallback>&, std::exception_ptr);
 
         static void onUpdate(jni::JNIEnv&,
-                            jni::Object<OfflineRegionUpdateMetadataCallback>,
+                            const jni::Object<OfflineRegionUpdateMetadataCallback>&,
                             mbgl::optional<mbgl::OfflineRegionMetadata>);
     };
 
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegion"; };
 
-    OfflineRegion(jni::JNIEnv&, jni::jlong, jni::Object<FileSource>);
+    OfflineRegion(jni::JNIEnv&, jni::jlong, const jni::Object<FileSource>&);
 
     ~OfflineRegion();
 
-    void setOfflineRegionObserver(jni::JNIEnv&, jni::Object<OfflineRegion::OfflineRegionObserver>);
+    void setOfflineRegionObserver(jni::JNIEnv&, const jni::Object<OfflineRegion::OfflineRegionObserver>&);
 
     void setOfflineRegionDownloadState(jni::JNIEnv&, jni::jint);
 
-    void getOfflineRegionStatus(jni::JNIEnv&, jni::Object<OfflineRegion::OfflineRegionStatusCallback>);
+    void getOfflineRegionStatus(jni::JNIEnv&, const jni::Object<OfflineRegion::OfflineRegionStatusCallback>&);
 
-    void deleteOfflineRegion(jni::JNIEnv&, jni::Object<OfflineRegionDeleteCallback>);
+    void deleteOfflineRegion(jni::JNIEnv&, const jni::Object<OfflineRegionDeleteCallback>&);
 
-    void updateOfflineRegionMetadata(jni::JNIEnv&, jni::Array<jni::jbyte>, jni::Object<OfflineRegionUpdateMetadataCallback>);
+    void updateOfflineRegionMetadata(jni::JNIEnv&, const jni::Array<jni::jbyte>&, const jni::Object<OfflineRegionUpdateMetadataCallback>&);
 
-    static jni::Object<OfflineRegion> New(jni::JNIEnv&, jni::Object<FileSource>, mbgl::OfflineRegion);
+    static jni::Local<jni::Object<OfflineRegion>> New(jni::JNIEnv&, const jni::Object<FileSource>&, mbgl::OfflineRegion);
 
-    static jni::Array<jni::jbyte> metadata(jni::JNIEnv&, mbgl::OfflineRegionMetadata);
+    static jni::Local<jni::Array<jni::jbyte>> metadata(jni::JNIEnv&, mbgl::OfflineRegionMetadata);
 
-    static mbgl::OfflineRegionMetadata metadata(jni::JNIEnv&, jni::Array<jni::jbyte>);
+    static mbgl::OfflineRegionMetadata metadata(jni::JNIEnv&, const jni::Array<jni::jbyte>&);
 
     static void registerNative(jni::JNIEnv&);
 

platform/android/src/offline/offline_region_definition.cpp

@@ -15,11 +15,11 @@ void OfflineRegionDefinition::registerNative(jni::JNIEnv& env) {
 }
 
 mbgl::OfflineRegionDefinition OfflineRegionDefinition::getDefinition(JNIEnv& env,
-                                                                     jni::Object<OfflineRegionDefinition> jDefinition) {
+                                                                     const jni::Object<OfflineRegionDefinition>& jDefinition) {
     if (jDefinition.IsInstanceOf(env, jni::Class<OfflineTilePyramidRegionDefinition>::Singleton(env))) {
-        return OfflineTilePyramidRegionDefinition::getDefinition(env, jni::Object<OfflineTilePyramidRegionDefinition>(*jDefinition));
+        return OfflineTilePyramidRegionDefinition::getDefinition(env, jni::Cast(env, jni::Class<OfflineTilePyramidRegionDefinition>::Singleton(env), jDefinition));
     } else if (jDefinition.IsInstanceOf(env, jni::Class<OfflineGeometryRegionDefinition>::Singleton(env))) {
-        return OfflineGeometryRegionDefinition::getDefinition(env, jni::Object<OfflineGeometryRegionDefinition>(*jDefinition));
+        return OfflineGeometryRegionDefinition::getDefinition(env, jni::Cast(env, jni::Class<OfflineGeometryRegionDefinition>::Singleton(env), jDefinition));
     }
 
     throw std::runtime_error("Unknown offline region definition java class");
@@ -27,21 +27,21 @@ mbgl::OfflineRegionDefinition OfflineRegionDefinition::getDefinition(JNIEnv& env
 
 // OfflineTilePyramidRegionDefinition //
 
-jni::Object<OfflineTilePyramidRegionDefinition> OfflineTilePyramidRegionDefinition::New(jni::JNIEnv& env, const mbgl::OfflineTilePyramidRegionDefinition& definition) {
-    static auto javaClass = jni::Class<OfflineTilePyramidRegionDefinition>::Singleton(env);
+jni::Local<jni::Object<OfflineRegionDefinition>> OfflineTilePyramidRegionDefinition::New(jni::JNIEnv& env, const mbgl::OfflineTilePyramidRegionDefinition& definition) {
+    static auto& javaClass = jni::Class<OfflineTilePyramidRegionDefinition>::Singleton(env);
     static auto constructor = javaClass.GetConstructor<jni::String, jni::Object<LatLngBounds>, jni::jdouble, jni::jdouble, jni::jfloat>(env);
 
     return javaClass.New(env, constructor,
-        *jni::SeizeLocal(env, jni::Make<jni::String>(env, definition.styleURL)),
-        *jni::SeizeLocal(env, LatLngBounds::New(env, definition.bounds)),
+        jni::Make<jni::String>(env, definition.styleURL),
+        LatLngBounds::New(env, definition.bounds),
         definition.minZoom,
         definition.maxZoom,
         definition.pixelRatio);
 }
 
-mbgl::OfflineTilePyramidRegionDefinition OfflineTilePyramidRegionDefinition::getDefinition(jni::JNIEnv& env, jni::Object<OfflineTilePyramidRegionDefinition> jDefinition) {
+mbgl::OfflineTilePyramidRegionDefinition OfflineTilePyramidRegionDefinition::getDefinition(jni::JNIEnv& env, const jni::Object<OfflineTilePyramidRegionDefinition>& jDefinition) {
     // Field references
-    static auto javaClass = jni::Class<OfflineTilePyramidRegionDefinition>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineTilePyramidRegionDefinition>::Singleton(env);
     static auto styleURLF = javaClass.GetField<jni::String>(env, "styleURL");
     static auto boundsF = javaClass.GetField<jni::Object<LatLngBounds>>(env, "bounds");
     static auto minZoomF = javaClass.GetField<jni::jdouble>(env, "minZoom");
@@ -49,8 +49,8 @@ mbgl::OfflineTilePyramidRegionDefinition OfflineTilePyramidRegionDefinition::get
     static auto pixelRatioF = javaClass.GetField<jni::jfloat>(env, "pixelRatio");
 
     return mbgl::OfflineTilePyramidRegionDefinition(
-        jni::Make<std::string>(env, *jni::SeizeLocal(env, jDefinition.Get(env, styleURLF))),
-        LatLngBounds::getLatLngBounds(env, *jni::SeizeLocal(env, jDefinition.Get(env, boundsF))),
+        jni::Make<std::string>(env, jDefinition.Get(env, styleURLF)),
+        LatLngBounds::getLatLngBounds(env, jDefinition.Get(env, boundsF)),
         jDefinition.Get(env, minZoomF),
         jDefinition.Get(env, maxZoomF),
         jDefinition.Get(env, pixelRatioF)
@@ -63,21 +63,21 @@ void OfflineTilePyramidRegionDefinition::registerNative(jni::JNIEnv& env) {
 
 // OfflineGeometryRegionDefinition //
 
-jni::Object<OfflineGeometryRegionDefinition> OfflineGeometryRegionDefinition::New(jni::JNIEnv& env, const mbgl::OfflineGeometryRegionDefinition& definition) {
-    static auto javaClass = jni::Class<OfflineGeometryRegionDefinition>::Singleton(env);
+jni::Local<jni::Object<OfflineRegionDefinition>> OfflineGeometryRegionDefinition::New(jni::JNIEnv& env, const mbgl::OfflineGeometryRegionDefinition& definition) {
+    static auto& javaClass = jni::Class<OfflineGeometryRegionDefinition>::Singleton(env);
     static auto constructor = javaClass.GetConstructor<jni::String, jni::Object<geojson::Geometry>, jni::jdouble, jni::jdouble, jni::jfloat>(env);
 
     return javaClass.New(env, constructor,
-        *jni::SeizeLocal(env, jni::Make<jni::String>(env, definition.styleURL)),
-        *jni::SeizeLocal(env, geojson::Geometry::New(env, definition.geometry)),
+        jni::Make<jni::String>(env, definition.styleURL),
+        geojson::Geometry::New(env, definition.geometry),
         definition.minZoom,
         definition.maxZoom,
         definition.pixelRatio);
 }
 
-mbgl::OfflineGeometryRegionDefinition OfflineGeometryRegionDefinition::getDefinition(jni::JNIEnv& env, jni::Object<OfflineGeometryRegionDefinition> jDefinition) {
+mbgl::OfflineGeometryRegionDefinition OfflineGeometryRegionDefinition::getDefinition(jni::JNIEnv& env, const jni::Object<OfflineGeometryRegionDefinition>& jDefinition) {
     // Field references
-    static auto javaClass = jni::Class<OfflineGeometryRegionDefinition>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineGeometryRegionDefinition>::Singleton(env);
     static auto styleURLF = javaClass.GetField<jni::String>(env, "styleURL");
     static auto geometryF = javaClass.GetField<jni::Object<geojson::Geometry>>(env, "geometry");
     static auto minZoomF = javaClass.GetField<jni::jdouble>(env, "minZoom");
@@ -85,8 +85,8 @@ mbgl::OfflineGeometryRegionDefinition OfflineGeometryRegionDefinition::getDefini
     static auto pixelRatioF = javaClass.GetField<jni::jfloat>(env, "pixelRatio");
 
     return mbgl::OfflineGeometryRegionDefinition(
-        jni::Make<std::string>(env, *jni::SeizeLocal(env, jDefinition.Get(env, styleURLF))),
-        geojson::Geometry::convert(env, *jni::SeizeLocal(env, jDefinition.Get(env, geometryF))),
+        jni::Make<std::string>(env, jDefinition.Get(env, styleURLF)),
+        geojson::Geometry::convert(env, jDefinition.Get(env, geometryF)),
         jDefinition.Get(env, minZoomF),
         jDefinition.Get(env, maxZoomF),
         jDefinition.Get(env, pixelRatioF)

platform/android/src/offline/offline_region_definition.hpp

@@ -12,27 +12,29 @@ public:
 
     static void registerNative(jni::JNIEnv&);
 
-    static mbgl::OfflineRegionDefinition getDefinition(JNIEnv& env, jni::Object<OfflineRegionDefinition> jDefinition);
+    static mbgl::OfflineRegionDefinition getDefinition(JNIEnv& env, const jni::Object<OfflineRegionDefinition>& jDefinition);
 };
 
-class OfflineTilePyramidRegionDefinition: public OfflineRegionDefinition {
+class OfflineTilePyramidRegionDefinition {
 public:
+    using SuperTag = OfflineRegionDefinition;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineTilePyramidRegionDefinition"; };
 
-    static jni::Object<OfflineTilePyramidRegionDefinition> New(jni::JNIEnv&, const mbgl::OfflineTilePyramidRegionDefinition&);
+    static jni::Local<jni::Object<OfflineRegionDefinition>> New(jni::JNIEnv&, const mbgl::OfflineTilePyramidRegionDefinition&);
 
-    static mbgl::OfflineTilePyramidRegionDefinition getDefinition(jni::JNIEnv&, jni::Object<OfflineTilePyramidRegionDefinition>);
+    static mbgl::OfflineTilePyramidRegionDefinition getDefinition(jni::JNIEnv&, const jni::Object<OfflineTilePyramidRegionDefinition>&);
 
     static void registerNative(jni::JNIEnv&);
 };
 
-class OfflineGeometryRegionDefinition: public OfflineRegionDefinition {
+class OfflineGeometryRegionDefinition {
 public:
+    using SuperTag = OfflineRegionDefinition;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineGeometryRegionDefinition"; };
 
-    static jni::Object<OfflineGeometryRegionDefinition> New(jni::JNIEnv&, const mbgl::OfflineGeometryRegionDefinition&);
+    static jni::Local<jni::Object<OfflineRegionDefinition>> New(jni::JNIEnv&, const mbgl::OfflineGeometryRegionDefinition&);
 
-    static mbgl::OfflineGeometryRegionDefinition getDefinition(jni::JNIEnv&, jni::Object<OfflineGeometryRegionDefinition>);
+    static mbgl::OfflineGeometryRegionDefinition getDefinition(jni::JNIEnv&, const jni::Object<OfflineGeometryRegionDefinition>&);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/offline/offline_region_error.cpp

@@ -3,7 +3,7 @@
 namespace mbgl {
 namespace android {
 
-jni::Object<OfflineRegionError> OfflineRegionError::New(jni::JNIEnv& env, mbgl::Response::Error error) {
+jni::Local<jni::Object<OfflineRegionError>> OfflineRegionError::New(jni::JNIEnv& env, mbgl::Response::Error error) {
 
     // Handle the value of reason independently of the underlying int value
     std::string reason;
@@ -28,12 +28,12 @@ jni::Object<OfflineRegionError> OfflineRegionError::New(jni::JNIEnv& env, mbgl::
             break;
     }
 
-    static auto javaClass = jni::Class<OfflineRegionError>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineRegionError>::Singleton(env);
     static auto constructor = javaClass.GetConstructor<jni::String, jni::String>(env);
 
     return javaClass.New(env, constructor,
-        *jni::SeizeLocal(env, jni::Make<jni::String>(env, reason)),
-        *jni::SeizeLocal(env, jni::Make<jni::String>(env, error.message)));
+        jni::Make<jni::String>(env, reason),
+        jni::Make<jni::String>(env, error.message));
 }
 
 void OfflineRegionError::registerNative(jni::JNIEnv& env) {

platform/android/src/offline/offline_region_error.hpp

@@ -10,7 +10,7 @@ class OfflineRegionError {
 public:
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegionError"; };
 
-    static jni::Object<OfflineRegionError> New(jni::JNIEnv&, mbgl::Response::Error);
+    static jni::Local<jni::Object<OfflineRegionError>> New(jni::JNIEnv&, mbgl::Response::Error);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/offline/offline_region_status.cpp

@@ -3,7 +3,7 @@
 namespace mbgl {
 namespace android {
 
-jni::Object<OfflineRegionStatus> OfflineRegionStatus::New(jni::JNIEnv& env, mbgl::OfflineRegionStatus status) {
+jni::Local<jni::Object<OfflineRegionStatus>> OfflineRegionStatus::New(jni::JNIEnv& env, mbgl::OfflineRegionStatus status) {
 
     // Convert to jint
     jint downloadState;
@@ -17,7 +17,7 @@ jni::Object<OfflineRegionStatus> OfflineRegionStatus::New(jni::JNIEnv& env, mbgl
     }
 
     // Create java object
-    static auto javaClass = jni::Class<OfflineRegionStatus>::Singleton(env);
+    static auto& javaClass = jni::Class<OfflineRegionStatus>::Singleton(env);
     static auto constructor = javaClass.GetConstructor<jint, jlong, jlong, jlong, jlong, jlong, jboolean>(env);
     return javaClass.New(env, constructor,
         downloadState,

platform/android/src/offline/offline_region_status.hpp

@@ -10,7 +10,7 @@ class OfflineRegionStatus {
 public:
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegionStatus"; };
 
-    static jni::Object<OfflineRegionStatus> New(jni::JNIEnv&, mbgl::OfflineRegionStatus status);
+    static jni::Local<jni::Object<OfflineRegionStatus>> New(jni::JNIEnv&, mbgl::OfflineRegionStatus status);
 
     static void registerNative(jni::JNIEnv&);
 };

platform/android/src/snapshotter/map_snapshot.cpp

@@ -16,18 +16,18 @@ MapSnapshot::MapSnapshot(float pixelRatio_, MapSnapshot::PointForFn pointForFn_,
 
 MapSnapshot::~MapSnapshot() = default;
 
-jni::Object<PointF> MapSnapshot::pixelForLatLng(jni::JNIEnv& env, jni::Object<LatLng> jLatLng) {
+jni::Local<jni::Object<PointF>> MapSnapshot::pixelForLatLng(jni::JNIEnv& env, jni::Object<LatLng>& jLatLng) {
     ScreenCoordinate point = pointForFn(LatLng::getLatLng(env, jLatLng));
     return PointF::New(env, point.x * pixelRatio, point.y * pixelRatio);
 }
 
-jni::Object<LatLng> MapSnapshot::latLngForPixel(jni::JNIEnv& env, jni::Object<PointF>jPoint) {
+jni::Local<jni::Object<LatLng>> MapSnapshot::latLngForPixel(jni::JNIEnv& env, jni::Object<PointF>& jPoint) {
     return LatLng::New(env, latLngForFn(PointF::getScreenCoordinate(env, jPoint)));
 }
 
 // Static methods //
 
-jni::Object<MapSnapshot> MapSnapshot::New(JNIEnv& env,
+jni::Local<jni::Object<MapSnapshot>> MapSnapshot::New(JNIEnv& env,
                                           PremultipliedImage&& image,
                                           float pixelRatio,
                                           std::vector<std::string> attributions,
@@ -38,7 +38,7 @@ jni::Object<MapSnapshot> MapSnapshot::New(JNIEnv& env,
     auto bitmap = Bitmap::CreateBitmap(env, std::move(image));
 
     // Create the Mapsnapshot peers
-    static auto javaClass = jni::Class<MapSnapshot>::Singleton(env);
+    static auto& javaClass = jni::Class<MapSnapshot>::Singleton(env);
     static auto constructor = javaClass.GetConstructor<jni::jlong, jni::Object<Bitmap>, jni::Array<jni::String>, jni::jboolean>(env);
     auto nativePeer = std::make_unique<MapSnapshot>(pixelRatio, pointForFn, latLngForFn);
     return javaClass.New(env, constructor, reinterpret_cast<jlong>(nativePeer.release()), bitmap, conversion::toArray(env, attributions), (jni::jboolean) showLogo);
@@ -46,7 +46,7 @@ jni::Object<MapSnapshot> MapSnapshot::New(JNIEnv& env,
 
 void MapSnapshot::registerNative(jni::JNIEnv& env) {
     // Lookup the class
-    static auto javaClass = jni::Class<MapSnapshot>::Singleton(env);
+    static auto& javaClass = jni::Class<MapSnapshot>::Singleton(env);
 
 #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 

platform/android/src/snapshotter/map_snapshot.hpp

@@ -23,7 +23,7 @@ public:
 
     static void registerNative(jni::JNIEnv&);
 
-    static jni::Object<MapSnapshot> New(JNIEnv& env,
+    static jni::Local<jni::Object<MapSnapshot>> New(JNIEnv& env,
                                         PremultipliedImage&& image,
                                         float pixelRatio,
                                         std::vector<std::string> attributions,
@@ -35,8 +35,8 @@ public:
     MapSnapshot(float pixelRatio, PointForFn, LatLngForFn);
     ~MapSnapshot();
 
-    jni::Object<PointF> pixelForLatLng(jni::JNIEnv&, jni::Object<LatLng>);
-    jni::Object<LatLng> latLngForPixel(jni::JNIEnv&, jni::Object<PointF>);
+    jni::Local<jni::Object<PointF>> pixelForLatLng(jni::JNIEnv&, jni::Object<LatLng>&);
+    jni::Local<jni::Object<LatLng>> latLngForPixel(jni::JNIEnv&, jni::Object<PointF>&);
 
 private:
     float pixelRatio;

platform/android/src/snapshotter/map_snapshotter.cpp

@@ -14,18 +14,18 @@ namespace mbgl {
 namespace android {
 
 MapSnapshotter::MapSnapshotter(jni::JNIEnv& _env,
-                               jni::Object<MapSnapshotter> _obj,
-                               jni::Object<FileSource> _jFileSource,
+                               const jni::Object<MapSnapshotter>& _obj,
+                               const jni::Object<FileSource>& _jFileSource,
                                jni::jfloat _pixelRatio,
                                jni::jint width,
                                jni::jint height,
-                               jni::String styleURL,
-                               jni::String styleJSON,
-                               jni::Object<LatLngBounds> region,
-                               jni::Object<CameraPosition> position,
+                               const jni::String& styleURL,
+                               const jni::String& styleJSON,
+                               const jni::Object<LatLngBounds>& region,
+                               const jni::Object<CameraPosition>& position,
                                jni::jboolean _showLogo,
-                               jni::String _programCacheDir)
-        : javaPeer(SeizeGenericWeak(_obj.NewWeakGlobalRef(_env).release()))
+                               const jni::String& _programCacheDir)
+        : javaPeer(_env, _obj)
         , pixelRatio(_pixelRatio)
         , threadPool(sharedThreadPool()) {
 
@@ -80,20 +80,19 @@ void MapSnapshotter::start(JNIEnv& env) {
             [this](std::exception_ptr err, PremultipliedImage image, std::vector<std::string> attributions, mbgl::MapSnapshotter::PointForFn pointForFn, mbgl::MapSnapshotter::LatLngForFn latLngForFn) {
         MBGL_VERIFY_THREAD(tid);
         android::UniqueEnv _env = android::AttachEnv();
-        static auto javaClass = jni::Class<MapSnapshotter>::Singleton(*_env);
+        static auto& javaClass = jni::Class<MapSnapshotter>::Singleton(*_env);
 
         if (err) {
             // error handler callback
             static auto onSnapshotFailed = javaClass.GetMethod<void (jni::String)>(*_env, "onSnapshotFailed");
-            javaPeer->Call(*_env, onSnapshotFailed,
-                *jni::SeizeLocal(*_env, jni::Make<jni::String>(*_env, util::toString(err))));
+            javaPeer.get(*_env).Call(*_env, onSnapshotFailed, jni::Make<jni::String>(*_env, util::toString(err)));
         } else {
             // Create the wrapper
             auto mapSnapshot = android::MapSnapshot::New(*_env, std::move(image), pixelRatio, attributions, showLogo, pointForFn, latLngForFn);
 
             // invoke callback
             static auto onSnapshotReady = javaClass.GetMethod<void (jni::Object<MapSnapshot>)>(*_env, "onSnapshotReady");
-            javaPeer->Call(*_env, onSnapshotReady, mapSnapshot);
+            javaPeer.get(*_env).Call(*_env, onSnapshotReady, mapSnapshot);
         }
 
         deactivateFilesource(*_env);
@@ -108,11 +107,11 @@ void MapSnapshotter::cancel(JNIEnv& env) {
     deactivateFilesource(env);
 }
 
-void MapSnapshotter::setStyleUrl(JNIEnv& env, jni::String styleURL) {
+void MapSnapshotter::setStyleUrl(JNIEnv& env, const jni::String& styleURL) {
     snapshotter->setStyleURL(jni::Make<std::string>(env, styleURL));
 }
 
-void MapSnapshotter::setStyleJson(JNIEnv& env, jni::String styleJSON) {
+void MapSnapshotter::setStyleJson(JNIEnv& env, const jni::String& styleJSON) {
     snapshotter->setStyleJSON(jni::Make<std::string>(env, styleJSON));
 }
 
@@ -121,12 +120,12 @@ void MapSnapshotter::setSize(JNIEnv&, jni::jint width, jni::jint height) {
     snapshotter->setSize(size);
 }
 
-void MapSnapshotter::setCameraPosition(JNIEnv& env, jni::Object<CameraPosition> position) {
+void MapSnapshotter::setCameraPosition(JNIEnv& env, const jni::Object<CameraPosition>& position) {
     auto options = CameraPosition::getCameraOptions(env, position);
     snapshotter->setCameraOptions(options);
 }
 
-void MapSnapshotter::setRegion(JNIEnv& env, jni::Object<LatLngBounds> region) {
+void MapSnapshotter::setRegion(JNIEnv& env, const jni::Object<LatLngBounds>& region) {
     snapshotter->setRegion(LatLngBounds::getLatLngBounds(env, region));
 }
 
@@ -151,13 +150,13 @@ void MapSnapshotter::deactivateFilesource(JNIEnv& env) {
 
 void MapSnapshotter::registerNative(jni::JNIEnv& env) {
     // Lookup the class
-    static auto javaClass = jni::Class<MapSnapshotter>::Singleton(env);
+    static auto& javaClass = jni::Class<MapSnapshotter>::Singleton(env);
 
 #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
     // Register the peer
     jni::RegisterNativePeer<MapSnapshotter>(env, javaClass, "nativePtr",
-                                            std::make_unique<MapSnapshotter, JNIEnv&, jni::Object<MapSnapshotter>, jni::Object<FileSource>, jni::jfloat, jni::jint, jni::jint, jni::String, jni::String, jni::Object<LatLngBounds>, jni::Object<CameraPosition>, jni::jboolean, jni::String>,
+                                            jni::MakePeer<MapSnapshotter, const jni::Object<MapSnapshotter>&, const jni::Object<FileSource>&, jni::jfloat, jni::jint, jni::jint, const jni::String&, const jni::String&, const jni::Object<LatLngBounds>&, const jni::Object<CameraPosition>&, jni::jboolean, const jni::String&>,
                                            "nativeInitialize",
                                            "finalize",
                                             METHOD(&MapSnapshotter::setStyleUrl, "setStyleUrl"),

platform/android/src/snapshotter/map_snapshotter.hpp

@@ -9,7 +9,6 @@
 #include "../map/camera_position.hpp"
 
 #include <jni/jni.hpp>
-#include "../jni/generic_global_ref_deleter.hpp"
 
 #include <memory>
 
@@ -26,29 +25,29 @@ public:
     static void registerNative(jni::JNIEnv&);
 
     MapSnapshotter(jni::JNIEnv&,
-                   jni::Object<MapSnapshotter>,
-                   jni::Object<FileSource>,
+                   const jni::Object<MapSnapshotter>&,
+                   const jni::Object<FileSource>&,
                    jni::jfloat pixelRatio,
                    jni::jint width,
                    jni::jint height,
-                   jni::String styleURL,
-                   jni::String styleJSON,
-                   jni::Object<LatLngBounds> region,
-                   jni::Object<CameraPosition> position,
+                   const jni::String& styleURL,
+                   const jni::String& styleJSON,
+                   const jni::Object<LatLngBounds>& region,
+                   const jni::Object<CameraPosition>& position,
                    jni::jboolean showLogo,
-                   jni::String programCacheDir);
+                   const jni::String& programCacheDir);
 
     ~MapSnapshotter();
 
-    void setStyleUrl(JNIEnv&, jni::String styleURL);
+    void setStyleUrl(JNIEnv&, const jni::String& styleURL);
 
-    void setStyleJson(JNIEnv&, jni::String styleJSON);
+    void setStyleJson(JNIEnv&, const jni::String& styleJSON);
 
     void setSize(JNIEnv&, jni::jint width, jni::jint height);
 
-    void setCameraPosition(JNIEnv&, jni::Object<CameraPosition> position);
+    void setCameraPosition(JNIEnv&, const jni::Object<CameraPosition>& position);
 
-    void setRegion(JNIEnv&, jni::Object<LatLngBounds> region);
+    void setRegion(JNIEnv&, const jni::Object<LatLngBounds>& region);
 
     void start(JNIEnv&);
 
@@ -58,7 +57,7 @@ private:
     MBGL_STORE_THREAD(tid);
 
     JavaVM *vm = nullptr;
-    GenericWeak<jni::Object<MapSnapshotter>> javaPeer;
+    jni::WeakReference<jni::Object<MapSnapshotter>, jni::EnvAttachingDeleter> javaPeer;
 
     float pixelRatio;
     bool showLogo;

platform/android/src/style/conversion/filter.cpp

@@ -8,11 +8,11 @@ namespace mbgl {
 namespace android {
 namespace conversion {
 
-optional<mbgl::style::Filter> toFilter(jni::JNIEnv& env, jni::Local<jni::Array<jni::Object<>>> jfilter) {
+optional<mbgl::style::Filter> toFilter(jni::JNIEnv& env, const jni::Array<jni::Object<>>& jfilter) {
     mbgl::optional<mbgl::style::Filter> filter;
     if (jfilter) {
       mbgl::style::conversion::Error error;
-      auto converted = mbgl::style::conversion::convert<mbgl::style::Filter>(Value(env, std::move(jfilter)), error);
+      auto converted = mbgl::style::conversion::convert<mbgl::style::Filter>(Value(env, jfilter), error);
       if (!converted) {
           mbgl::Log::Error(mbgl::Event::JNI, "Error converting filter: " + error.message);
       }

platform/android/src/style/conversion/filter.hpp

@@ -9,7 +9,7 @@ namespace mbgl {
 namespace android {
 namespace conversion {
 
-optional<mbgl::style::Filter> toFilter(jni::JNIEnv&, jni::Local<jni::Array<jni::Object<>>>);
+optional<mbgl::style::Filter> toFilter(jni::JNIEnv&, const jni::Array<jni::Object<>>&);
 
 } // namespace conversion
 } // namespace android

platform/android/src/style/conversion/position.cpp

@@ -4,7 +4,7 @@ namespace mbgl {
 namespace android {
 namespace conversion {
 
-Result<jni::Object<Position>> Converter<jni::Object<Position>, mbgl::style::Position>::operator()(jni::JNIEnv &env, const mbgl::style::Position &value) const {
+Result<jni::Local<jni::Object<Position>>> Converter<jni::Local<jni::Object<Position>>, mbgl::style::Position>::operator()(jni::JNIEnv &env, const mbgl::style::Position &value) const {
     std::array<float, 3> cartPosition = value.getSpherical();
     return Position::fromPosition(env, cartPosition[0], cartPosition[1], cartPosition[2]);
 }

platform/android/src/style/conversion/position.hpp

@@ -11,8 +11,8 @@ namespace android {
 namespace conversion {
 
 template <>
-struct Converter<jni::Object<Position>, mbgl::style::Position> {
-    Result<jni::Object<Position>> operator()(jni::JNIEnv &env, const mbgl::style::Position &value) const;
+struct Converter<jni::Local<jni::Object<Position>>, mbgl::style::Position> {
+    Result<jni::Local<jni::Object<Position>>> operator()(jni::JNIEnv &env, const mbgl::style::Position &value) const;
 };
 
 template <>

platform/android/src/style/conversion/property_expression.hpp

@@ -12,8 +12,8 @@ namespace android {
 namespace conversion {
 
 template <class T>
-struct Converter<jni::Object<android::gson::JsonElement>, mbgl::style::PropertyExpression<T>> {
-    Result<jni::Object<android::gson::JsonElement>> operator()(jni::JNIEnv& env, const mbgl::style::PropertyExpression<T>& value) const {
+struct Converter<jni::Local<jni::Object<android::gson::JsonElement>>, mbgl::style::PropertyExpression<T>> {
+    Result<jni::Local<jni::Object<android::gson::JsonElement>>> operator()(jni::JNIEnv& env, const mbgl::style::PropertyExpression<T>& value) const {
         return gson::JsonElement::New(env, value.getExpression().serialize());
     }
 };

platform/android/src/style/conversion/property_value.hpp

@@ -19,16 +19,16 @@ class PropertyValueEvaluator {
 public:
     PropertyValueEvaluator(jni::JNIEnv& _env) : env(_env) {}
 
-    jni::jobject* operator()(const mbgl::style::Undefined) const {
-        return nullptr;
+    jni::Local<jni::Object<>> operator()(const mbgl::style::Undefined) const {
+        return jni::Local<jni::Object<>>(env, nullptr);
     }
 
-    jni::jobject* operator()(const T& value) const {
-        return *convert<jni::jobject*>(env, value);
+    jni::Local<jni::Object<>> operator()(const T& value) const {
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, value));
     }
 
-    jni::jobject* operator()(const mbgl::style::PropertyExpression<T>& value) const {
-        return *convert<jni::Object<android::gson::JsonElement>>(env, value);
+    jni::Local<jni::Object<>> operator()(const mbgl::style::PropertyExpression<T>& value) const {
+        return std::move(*convert<jni::Local<jni::Object<android::gson::JsonElement>>>(env, value));
     }
 
 private:
@@ -39,8 +39,8 @@ private:
  * Convert core property values to java
  */
 template <class T>
-struct Converter<jni::jobject*, mbgl::style::PropertyValue<T>> {
-    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::PropertyValue<T>& value) const {
+struct Converter<jni::Local<jni::Object<>>, mbgl::style::PropertyValue<T>> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const mbgl::style::PropertyValue<T>& value) const {
         PropertyValueEvaluator<T> evaluator(env);
         return value.evaluate(evaluator);
     }
@@ -50,10 +50,10 @@ struct Converter<jni::jobject*, mbgl::style::PropertyValue<T>> {
  * Convert core heat map color property value to java
  */
 template <>
-struct Converter<jni::jobject*, mbgl::style::ColorRampPropertyValue> {
-    Result<jni::jobject*> operator()(jni::JNIEnv& env, const mbgl::style::ColorRampPropertyValue& value) const {
+struct Converter<jni::Local<jni::Object<>>, mbgl::style::ColorRampPropertyValue> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const mbgl::style::ColorRampPropertyValue& value) const {
         PropertyValueEvaluator<mbgl::style::ColorRampPropertyValue> evaluator(env);
-        return *convert<jni::jobject*>(env, value.evaluate(evaluator));
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, value.evaluate(evaluator)));
     }
 };
 

platform/android/src/style/conversion/transition_options.cpp

@@ -4,7 +4,7 @@ namespace mbgl {
 namespace android {
 namespace conversion {
 
-Result<jni::Object<TransitionOptions>> Converter<jni::Object<TransitionOptions>, mbgl::style::TransitionOptions>::operator()(jni::JNIEnv& env, const mbgl::style::TransitionOptions& value) const {
+Result<jni::Local<jni::Object<TransitionOptions>>> Converter<jni::Local<jni::Object<TransitionOptions>>, mbgl::style::TransitionOptions>::operator()(jni::JNIEnv& env, const mbgl::style::TransitionOptions& value) const {
     return TransitionOptions::fromTransitionOptions(env,
         std::chrono::duration_cast<std::chrono::milliseconds>(value.duration.value_or(mbgl::Duration::zero())).count(),
         std::chrono::duration_cast<std::chrono::milliseconds>(value.delay.value_or(mbgl::Duration::zero())).count()

platform/android/src/style/conversion/transition_options.hpp

@@ -12,8 +12,8 @@ namespace android {
 namespace conversion {
 
 template<>
-struct Converter<jni::Object<TransitionOptions>, mbgl::style::TransitionOptions> {
-    Result<jni::Object<TransitionOptions>> operator()(jni::JNIEnv&, const mbgl::style::TransitionOptions&) const;
+struct Converter<jni::Local<jni::Object<TransitionOptions>>, mbgl::style::TransitionOptions> {
+    Result<jni::Local<jni::Object<TransitionOptions>>> operator()(jni::JNIEnv&, const mbgl::style::TransitionOptions&) const;
 };
 
 }

platform/android/src/style/layers/background_layer.cpp

@@ -13,7 +13,7 @@ namespace android {
     /**
      * Creates an owning peer object (for layers not attached to the map) from the JVM side
      */
-    BackgroundLayer::BackgroundLayer(jni::JNIEnv& env, jni::String layerId)
+    BackgroundLayer::BackgroundLayer(jni::JNIEnv& env, jni::String& layerId)
         : Layer(env, std::make_unique<mbgl::style::BackgroundLayer>(jni::Make<std::string>(env, layerId))) {
     }
 
@@ -35,16 +35,15 @@ namespace android {
 
     // Property getters
 
-    jni::Object<jni::ObjectTag> BackgroundLayer::getBackgroundColor(jni::JNIEnv& env) {
+    jni::Local<jni::Object<>> BackgroundLayer::getBackgroundColor(jni::JNIEnv& env) {
         using namespace mbgl::android::conversion;
-        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundColor());
-        return jni::Object<jni::ObjectTag>(*converted);
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundColor()));
     }
 
-    jni::Object<TransitionOptions> BackgroundLayer::getBackgroundColorTransition(jni::JNIEnv& env) {
+    jni::Local<jni::Object<TransitionOptions>> BackgroundLayer::getBackgroundColorTransition(jni::JNIEnv& env) {
         using namespace mbgl::android::conversion;
         mbgl::style::TransitionOptions options = layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundColorTransition();
-        return *convert<jni::Object<TransitionOptions>>(env, options);
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
     }
 
     void BackgroundLayer::setBackgroundColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
@@ -54,16 +53,15 @@ namespace android {
         layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::setBackgroundColorTransition(options);
     }
 
-    jni::Object<jni::ObjectTag> BackgroundLayer::getBackgroundPattern(jni::JNIEnv& env) {
+    jni::Local<jni::Object<>> BackgroundLayer::getBackgroundPattern(jni::JNIEnv& env) {
         using namespace mbgl::android::conversion;
-        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundPattern());
-        return jni::Object<jni::ObjectTag>(*converted);
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundPattern()));
     }
 
-    jni::Object<TransitionOptions> BackgroundLayer::getBackgroundPatternTransition(jni::JNIEnv& env) {
+    jni::Local<jni::Object<TransitionOptions>> BackgroundLayer::getBackgroundPatternTransition(jni::JNIEnv& env) {
         using namespace mbgl::android::conversion;
         mbgl::style::TransitionOptions options = layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundPatternTransition();
-        return *convert<jni::Object<TransitionOptions>>(env, options);
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
     }
 
     void BackgroundLayer::setBackgroundPatternTransition(jni::JNIEnv&, jlong duration, jlong delay) {
@@ -73,16 +71,15 @@ namespace android {
         layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::setBackgroundPatternTransition(options);
     }
 
-    jni::Object<jni::ObjectTag> BackgroundLayer::getBackgroundOpacity(jni::JNIEnv& env) {
+    jni::Local<jni::Object<>> BackgroundLayer::getBackgroundOpacity(jni::JNIEnv& env) {
         using namespace mbgl::android::conversion;
-        Result<jni::jobject*> converted = convert<jni::jobject*>(env, layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundOpacity());
-        return jni::Object<jni::ObjectTag>(*converted);
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundOpacity()));
     }
 
-    jni::Object<TransitionOptions> BackgroundLayer::getBackgroundOpacityTransition(jni::JNIEnv& env) {
+    jni::Local<jni::Object<TransitionOptions>> BackgroundLayer::getBackgroundOpacityTransition(jni::JNIEnv& env) {
         using namespace mbgl::android::conversion;
         mbgl::style::TransitionOptions options = layer.as<mbgl::style::BackgroundLayer>()->BackgroundLayer::getBackgroundOpacityTransition();
-        return *convert<jni::Object<TransitionOptions>>(env, options);
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
     }
 
     void BackgroundLayer::setBackgroundOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
@@ -93,22 +90,22 @@ namespace android {
     }
 
 
-    jni::jobject* BackgroundLayer::createJavaPeer(jni::JNIEnv& env) {
-        static auto javaClass = jni::Class<BackgroundLayer>::Singleton(env);
+    jni::Local<jni::Object<Layer>> BackgroundLayer::createJavaPeer(jni::JNIEnv& env) {
+        static auto& javaClass = jni::Class<BackgroundLayer>::Singleton(env);
         static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
         return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(this));
     }
 
     void BackgroundLayer::registerNative(jni::JNIEnv& env) {
         // Lookup the class
-        static auto javaClass = jni::Class<BackgroundLayer>::Singleton(env);
+        static auto& javaClass = jni::Class<BackgroundLayer>::Singleton(env);
 
         #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
 
         // Register the peer
         jni::RegisterNativePeer<BackgroundLayer>(
             env, javaClass, "nativePtr",
-            std::make_unique<BackgroundLayer, JNIEnv&, jni::String>,
+            jni::MakePeer<BackgroundLayer, jni::String&>,
             "initialize",
             "finalize",
             METHOD(&BackgroundLayer::getBackgroundColorTransition, "nativeGetBackgroundColorTransition"),

platform/android/src/style/layers/background_layer.hpp

@@ -12,12 +12,12 @@ namespace android {
 
 class BackgroundLayer : public Layer {
 public:
-
+    using SuperTag = Layer;
     static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/BackgroundLayer"; };
 
     static void registerNative(jni::JNIEnv&);
 
-    BackgroundLayer(jni::JNIEnv&, jni::String);
+    BackgroundLayer(jni::JNIEnv&, jni::String&);
 
     BackgroundLayer(mbgl::Map&, mbgl::style::BackgroundLayer&);
 
@@ -27,18 +27,18 @@ public:
 
     // Properties
 
-    jni::Object<jni::ObjectTag> getBackgroundColor(jni::JNIEnv&);
+    jni::Local<jni::Object<jni::ObjectTag>> getBackgroundColor(jni::JNIEnv&);
     void setBackgroundColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
-    jni::Object<TransitionOptions> getBackgroundColorTransition(jni::JNIEnv&);
+    jni::Local<jni::Object<TransitionOptions>> getBackgroundColorTransition(jni::JNIEnv&);
 
-    jni::Object<jni::ObjectTag> getBackgroundPattern(jni::JNIEnv&);
+    jni::Local<jni::Object<jni::ObjectTag>> getBackgroundPattern(jni::JNIEnv&);
     void setBackgroundPatternTransition(jni::JNIEnv&, jlong duration, jlong delay);
-    jni::Object<TransitionOptions> getBackgroundPatternTransition(jni::JNIEnv&);
+    jni::Local<jni::Object<TransitionOptions>> getBackgroundPatternTransition(jni::JNIEnv&);
 
-    jni::Object<jni::ObjectTag> getBackgroundOpacity(jni::JNIEnv&);
+    jni::Local<jni::Object<jni::ObjectTag>> getBackgroundOpacity(jni::JNIEnv&);
     void setBackgroundOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
-    jni::Object<TransitionOptions> getBackgroundOpacityTransition(jni::JNIEnv&);
-    jni::jobject* createJavaPeer(jni::JNIEnv&);
+    jni::Local<jni::Object<TransitionOptions>> getBackgroundOpacityTransition(jni::JNIEnv&);
+    jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
 
 }; // class BackgroundLayer