[android] jni.hpp 4.0.0

7 files changed, 48 insertions, 51 deletions

diff --git a/platform/android/src/gson/json_array.cpp b/platform/android/src/gson/json_array.cpp
index b5fb85e5d9..8ffa658b76 100644
--- a/platform/android/src/gson/json_array.cpp
+++ b/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));
             }
         }
     }
diff --git a/platform/android/src/gson/json_array.hpp b/platform/android/src/gson/json_array.hpp
index b41596819f..24d5d3d291 100644
--- a/platform/android/src/gson/json_array.hpp
+++ b/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&);
 };
diff --git a/platform/android/src/gson/json_element.cpp b/platform/android/src/gson/json_element.cpp
index 28cb368386..7c9a34c03c 100644
--- a/platform/android/src/gson/json_element.cpp
+++ b/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();
         }
diff --git a/platform/android/src/gson/json_element.hpp b/platform/android/src/gson/json_element.hpp
index 384459dc41..e3b8a0268d 100644
--- a/platform/android/src/gson/json_element.hpp
+++ b/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&);
 };
diff --git a/platform/android/src/gson/json_object.cpp b/platform/android/src/gson/json_object.cpp
index 5dcb07642f..10d244ee48 100644
--- a/platform/android/src/gson/json_object.cpp
+++ b/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);
         });
     }
diff --git a/platform/android/src/gson/json_object.hpp b/platform/android/src/gson/json_object.hpp
index 256161f0d9..b8916f8ae1 100644
--- a/platform/android/src/gson/json_object.hpp
+++ b/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&);
 };
diff --git a/platform/android/src/gson/json_primitive.hpp b/platform/android/src/gson/json_primitive.hpp
index fb3eefc855..36f138d902 100644
--- a/platform/android/src/gson/json_primitive.hpp
+++ b/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&);