diff options
author | Ivo van Dongen <info@ivovandongen.nl> | 2017-03-22 15:05:03 +0200 |
---|---|---|
committer | Ivo van Dongen <ivovandongen@users.noreply.github.com> | 2017-03-28 15:44:22 +0300 |
commit | fa7489fb7ea8ec85cb746e0bc497518d72c638b9 (patch) | |
tree | 477c100890466ca0093af9e101554dca530f9ae8 | |
parent | f70f604e5b99062a24764716ccdeda64c36320be (diff) | |
download | qtlocation-mapboxgl-fa7489fb7ea8ec85cb746e0bc497518d72c638b9.tar.gz |
[android] geojson conversion optimisation
47 files changed, 1266 insertions, 134 deletions
diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/sources/GeoJsonSource.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/sources/GeoJsonSource.java index b253595713..3c1a325169 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/sources/GeoJsonSource.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/sources/GeoJsonSource.java @@ -11,7 +11,6 @@ import com.mapbox.services.commons.geojson.FeatureCollection; import java.net.URL; import java.util.ArrayList; import java.util.Arrays; -import java.util.HashMap; import java.util.List; /** @@ -133,8 +132,7 @@ public class GeoJsonSource extends Source { * @param features the GeoJSON {@link FeatureCollection} */ public void setGeoJson(FeatureCollection features) { - checkValidity(); - setGeoJson(features.toJson()); + nativeSetFeatureCollection(features); } /** @@ -143,8 +141,7 @@ public class GeoJsonSource extends Source { * @param json the raw GeoJson FeatureCollection string */ public void setGeoJson(String json) { - checkValidity(); - setRawJson(json); + nativeSetGeoJsonString(json); } /** @@ -153,7 +150,6 @@ public class GeoJsonSource extends Source { * @param url the GeoJSON FeatureCollection url */ public void setUrl(URL url) { - checkValidity(); setUrl(url.toExternalForm()); } @@ -163,7 +159,6 @@ public class GeoJsonSource extends Source { * @param url the GeoJSON FeatureCollection url */ public void setUrl(String url) { - checkValidity(); nativeSetUrl(url); } @@ -179,19 +174,13 @@ public class GeoJsonSource extends Source { return features != null ? Arrays.asList(features) : new ArrayList<Feature>(); } - protected void setRawJson(String geoJson) { - // Wrap the String in a map as an Object is expected by the - // style conversion template - HashMap<String, String> wrapper = new HashMap<>(); - wrapper.put("data", geoJson); - nativeSetGeoJson(wrapper); - } - protected native void initialize(String layerId, Object options); protected native void nativeSetUrl(String url); - private native void nativeSetGeoJson(Object geoJson); + private native void nativeSetGeoJsonString(String geoJson); + + private native void nativeSetFeatureCollection(FeatureCollection geoJson); private native Feature[] querySourceFeatures(Object[] filter); diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/sources/Source.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/sources/Source.java index 6826fed1b5..62bfcb818f 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/sources/Source.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/sources/Source.java @@ -5,7 +5,6 @@ package com.mapbox.mapboxsdk.style.sources; */ public abstract class Source { private long nativePtr; - private boolean invalidated; /** * Internal use @@ -25,7 +24,6 @@ public abstract class Source { * @return the source id */ public String getId() { - checkValidity(); return nativeGetId(); } @@ -40,16 +38,4 @@ public abstract class Source { protected native String nativeGetId(); - protected void checkValidity() { - if (invalidated) { - throw new RuntimeException("Layer has been invalidated. Request a new reference after adding"); - } - } - - /** - * Internal use - invalidates the source for further use (after adding it to the map) - */ - public final void invalidate() { - this.invalidated = true; - } } diff --git a/platform/android/config.cmake b/platform/android/config.cmake index 86413d0d16..8a590b1f20 100644 --- a/platform/android/config.cmake +++ b/platform/android/config.cmake @@ -184,9 +184,29 @@ add_library(mbgl-android STATIC platform/android/src/graphics/rectf.cpp platform/android/src/graphics/rectf.hpp + # GeoJSON + platform/android/src/geojson/feature.cpp + platform/android/src/geojson/feature.hpp + platform/android/src/geojson/feature_collection.cpp + platform/android/src/geojson/feature_collection.hpp + platform/android/src/geojson/geometry.cpp + platform/android/src/geojson/geometry.hpp + platform/android/src/geojson/line_string.cpp + platform/android/src/geojson/line_string.hpp + platform/android/src/geojson/multi_line_string.cpp + platform/android/src/geojson/multi_line_string.hpp + platform/android/src/geojson/multi_point.cpp + platform/android/src/geojson/multi_point.hpp + platform/android/src/geojson/multi_polygon.cpp + platform/android/src/geojson/multi_polygon.hpp + platform/android/src/geojson/point.cpp + platform/android/src/geojson/point.hpp + platform/android/src/geojson/polygon.cpp + platform/android/src/geojson/polygon.hpp + platform/android/src/geojson/position.cpp + platform/android/src/geojson/position.hpp + # Geometry - platform/android/src/geometry/feature.cpp - platform/android/src/geometry/feature.hpp platform/android/src/geometry/lat_lng.cpp platform/android/src/geometry/lat_lng.hpp platform/android/src/geometry/lat_lng_bounds.cpp @@ -194,6 +214,16 @@ add_library(mbgl-android STATIC platform/android/src/geometry/projected_meters.cpp platform/android/src/geometry/projected_meters.hpp + # GSon + platform/android/src/gson/json_array.cpp + platform/android/src/gson/json_array.hpp + platform/android/src/gson/json_element.cpp + platform/android/src/gson/json_element.hpp + platform/android/src/gson/json_object.cpp + platform/android/src/gson/json_object.hpp + platform/android/src/gson/json_primitive.cpp + platform/android/src/gson/json_primitive.hpp + # Annotation platform/android/src/annotation/marker.cpp platform/android/src/annotation/marker.hpp diff --git a/platform/android/src/geometry/conversion/feature.hpp b/platform/android/src/geojson/conversion/feature.hpp index 921138e859..86aa5fc03c 100644 --- a/platform/android/src/geometry/conversion/feature.hpp +++ b/platform/android/src/geojson/conversion/feature.hpp @@ -170,8 +170,8 @@ struct Converter<jni::jobject*, std::unordered_map<std::string, mbgl::Value>> { template <> -struct Converter<jni::Object<Feature>, mbgl::Feature> { - Result<jni::Object<Feature>> operator()(jni::JNIEnv& env, const mbgl::Feature& value) const { +struct Converter<jni::Object<android::geojson::Feature>, mbgl::Feature> { + Result<jni::Object<android::geojson::Feature>> operator()(jni::JNIEnv& env, const mbgl::Feature& value) const { // Convert Id FeatureIdVisitor idEvaluator; @@ -179,13 +179,13 @@ struct Converter<jni::Object<Feature>, mbgl::Feature> { auto jid = jni::Make<jni::String>(env, id); // Convert properties - auto properties = jni::Object<JsonObject>(*convert<jni::jobject*>(env, value.properties)); + auto properties = jni::Object<gson::JsonObject>(*convert<jni::jobject*>(env, value.properties)); // Convert geometry - auto geometry = jni::Object<Geometry>(*convert<jni::jobject*>(env, value.geometry)); + auto geometry = jni::Object<android::geojson::Geometry>(*convert<jni::jobject*>(env, value.geometry)); // Create feature - auto feature = Feature::fromGeometry(env, geometry, properties, jid); + auto feature = android::geojson::Feature::fromGeometry(env, geometry, properties, jid); //Cleanup jni::DeleteLocalRef(env, jid); @@ -197,13 +197,13 @@ struct Converter<jni::Object<Feature>, mbgl::Feature> { }; template <> -struct Converter<jni::Array<jni::Object<Feature>>, std::vector<mbgl::Feature>> { - Result<jni::Array<jni::Object<Feature>>> operator()(jni::JNIEnv& env, const std::vector<mbgl::Feature>& value) const { - +struct Converter<jni::Array<jni::Object<android::geojson::Feature>>, std::vector<mbgl::Feature>> { + Result<jni::Array<jni::Object<android::geojson::Feature>>> operator()(jni::JNIEnv& env, const std::vector<mbgl::Feature>& value) const { + using namespace mbgl::android::geojson; auto features = jni::Array<jni::Object<Feature>>::New(env, value.size(), Feature::javaClass); for(size_t i = 0; i < value.size(); i = i + 1) { - auto converted = *convert<jni::Object<Feature>, mbgl::Feature>(env, value.at(i)); + auto converted = *convert<jni::Object<android::geojson::Feature>, mbgl::Feature>(env, value.at(i)); features.Set(env, i, converted); jni::DeleteLocalRef(env, converted); } diff --git a/platform/android/src/geometry/conversion/geometry.hpp b/platform/android/src/geojson/conversion/geometry.hpp index 2ca63e2c11..2ca63e2c11 100644 --- a/platform/android/src/geometry/conversion/geometry.hpp +++ b/platform/android/src/geojson/conversion/geometry.hpp diff --git a/platform/android/src/geojson/feature.cpp b/platform/android/src/geojson/feature.cpp new file mode 100644 index 0000000000..a6b387cd15 --- /dev/null +++ b/platform/android/src/geojson/feature.cpp @@ -0,0 +1,63 @@ +#include "feature.hpp" + +#include "geometry.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + +mbgl::Feature Feature::convert(jni::JNIEnv& env, jni::Object<Feature> jFeature) { + // Convert + auto jGeometry = getGeometry(env, jFeature); + auto jProperties = Feature::getProperties(env, jFeature); + + std::experimental::optional<mapbox::geometry::identifier> id; + auto jId = Feature::getId(env, jFeature); + if (jId) { + id = { jni::Make<std::string>(env, jId) }; + } + + auto feature = mbgl::Feature { + Geometry::convert(env, jGeometry), + gson::JsonObject::convert(env, jProperties), + id + }; + + // Cleanup + jni::DeleteLocalRef(env, jGeometry); + jni::DeleteLocalRef(env, jProperties); + jni::DeleteLocalRef(env, jId); + + return feature; +} + +jni::Object<Geometry> Feature::getGeometry(jni::JNIEnv& env, jni::Object<Feature> jFeature) { + static auto method = Feature::javaClass.GetMethod<jni::Object<Geometry> ()>(env, "getGeometry"); + return jFeature.Call(env, method); +} + +jni::Object<gson::JsonObject> Feature::getProperties(jni::JNIEnv& env, jni::Object<Feature> jFeature) { + static auto method = Feature::javaClass.GetMethod<jni::Object<gson::JsonObject> ()>(env, "getProperties"); + return jFeature.Call(env, method); +} + +jni::String Feature::getId(jni::JNIEnv& env, jni::Object<Feature> jFeature) { + static auto method = Feature::javaClass.GetMethod<jni::String ()>(env, "getId"); + return jFeature.Call(env, method); +} + +jni::Object<Feature> Feature::fromGeometry(jni::JNIEnv& env, jni::Object<Geometry> geometry, jni::Object<gson::JsonObject> properties, jni::String id) { + static auto method = Feature::javaClass.GetStaticMethod<jni::Object<Feature> (jni::Object<Geometry>, jni::Object<gson::JsonObject>, jni::String)>(env, "fromGeometry"); + return Feature::javaClass.Call(env, method, geometry, properties, id); +} + +void Feature::registerNative(jni::JNIEnv& env) { + // Lookup the class + Feature::javaClass = *jni::Class<Feature>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<Feature> Feature::javaClass; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geometry/feature.hpp b/platform/android/src/geojson/feature.hpp index 7f2733430c..b5d856cc42 100644 --- a/platform/android/src/geometry/feature.hpp +++ b/platform/android/src/geojson/feature.hpp @@ -1,7 +1,8 @@ #pragma once -#include <mbgl/util/noncopyable.hpp> +#include <mbgl/util/feature.hpp> #include <mbgl/util/geometry.hpp> +#include <mbgl/util/noncopyable.hpp> #include <jni/jni.hpp> @@ -10,13 +11,22 @@ namespace mbgl { namespace android { +namespace geojson { class Feature : private mbgl::util::noncopyable { public: static constexpr auto Name() { return "com/mapbox/services/commons/geojson/Feature"; }; - static jni::Object<Feature> fromGeometry(jni::JNIEnv&, jni::Object<Geometry>, jni::Object<JsonObject>, jni::String); + static jni::Object<Feature> fromGeometry(jni::JNIEnv&, jni::Object<Geometry>, jni::Object<gson::JsonObject>, jni::String); + + static mbgl::Feature convert(jni::JNIEnv&, jni::Object<Feature>); + + static jni::Object<Geometry> getGeometry(jni::JNIEnv&, jni::Object<Feature>); + + static jni::String getId(jni::JNIEnv&, jni::Object<Feature>); + + static jni::Object<gson::JsonObject> getProperties(jni::JNIEnv&, jni::Object<Feature>); static jni::Class<Feature> javaClass; @@ -24,6 +34,6 @@ public: }; - +} // namespace geojson } // namespace android } // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/feature_collection.cpp b/platform/android/src/geojson/feature_collection.cpp new file mode 100644 index 0000000000..2f156532ae --- /dev/null +++ b/platform/android/src/geojson/feature_collection.cpp @@ -0,0 +1,40 @@ +#include "feature_collection.hpp" + +#include "feature.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + +mbgl::FeatureCollection FeatureCollection::convert(jni::JNIEnv& env, jni::Object<FeatureCollection> jCollection) { + auto jFeatureList = FeatureCollection::getFeatures(env, jCollection); + auto jFeatures = java::util::List::toArray<Feature>(env, jFeatureList); + auto size = size_t(jFeatures.Length(env)); + + auto collection = mbgl::FeatureCollection(); + collection.reserve(size); + + for (size_t i = 0; i < size; i++) { + auto jFeature = jFeatures.Get(env, i); + collection.push_back(Feature::convert(env, jFeature)); + jni::DeleteLocalRef(env, jFeature); + } + + return collection; +} + +jni::Object<java::util::List> FeatureCollection::getFeatures(jni::JNIEnv& env, jni::Object<FeatureCollection> jCollection) { + static auto method = FeatureCollection::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "getFeatures"); + return jCollection.Call(env, method); +} + +void FeatureCollection::registerNative(jni::JNIEnv& env) { + // Lookup the class + javaClass = *jni::Class<FeatureCollection>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<FeatureCollection> FeatureCollection::javaClass; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/feature_collection.hpp b/platform/android/src/geojson/feature_collection.hpp new file mode 100644 index 0000000000..8e9717e82b --- /dev/null +++ b/platform/android/src/geojson/feature_collection.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include "../java/util.hpp" + +#include <mbgl/util/geojson.hpp> +#include <mbgl/util/noncopyable.hpp> + +#include <jni/jni.hpp> + +namespace mbgl { +namespace android { +namespace geojson { + +class FeatureCollection : private mbgl::util::noncopyable { +public: + static constexpr auto Name() { return "com/mapbox/services/commons/geojson/FeatureCollection"; }; + + static mbgl::FeatureCollection convert(jni::JNIEnv&, jni::Object<FeatureCollection>); + + static jni::Object<java::util::List> getFeatures(jni::JNIEnv&, jni::Object<FeatureCollection>); + + static jni::Class<FeatureCollection> javaClass; + + static void registerNative(jni::JNIEnv&); +}; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/geometry.cpp b/platform/android/src/geojson/geometry.cpp new file mode 100644 index 0000000000..33bb4ee3db --- /dev/null +++ b/platform/android/src/geojson/geometry.cpp @@ -0,0 +1,52 @@ +#include "geometry.hpp" + +#include "point.hpp" +#include "multi_point.hpp" +#include "line_string.hpp" +#include "multi_line_string.hpp" +#include "polygon.hpp" +#include "multi_polygon.hpp" + +#include <string> + +namespace mbgl { +namespace android { +namespace geojson { + +mapbox::geojson::geometry Geometry::convert(jni::JNIEnv &env, jni::Object<Geometry> jGeometry) { + auto type = Geometry::getType(env, jGeometry); + if (type == Point::Type()) { + return { Point::convert(env, jni::Object<Point>(jGeometry.Get())) }; + } else if (type == MultiPoint::Type()) { + return { MultiPoint::convert(env, jni::Object<MultiPoint>(jGeometry.Get())) }; + } else if (type == LineString::Type()) { + return { LineString::convert(env, jni::Object<LineString>(jGeometry.Get())) }; + } else if (type == MultiLineString::Type()) { + return { MultiLineString::convert(env, jni::Object<MultiLineString>(jGeometry.Get())) }; + } else if (type == Polygon::Type()) { + return { Polygon::convert(env, jni::Object<Polygon>(jGeometry.Get())) }; + } else if (type == MultiPolygon::Type()) { + return { MultiPolygon::convert(env, jni::Object<MultiPolygon>(jGeometry.Get())) }; + } + + throw std::runtime_error(std::string {"Unsupported GeoJSON type: " } + type); +} + +std::string Geometry::getType(jni::JNIEnv &env, jni::Object<Geometry> jGeometry) { + static auto method = Geometry::javaClass.GetMethod<jni::String ()>(env, "getType"); + auto jType = jGeometry.Call(env, method); + auto type = jni::Make<std::string>(env, jType); + jni::DeleteLocalRef(env, jType); + return type; +} + +void Geometry::registerNative(jni::JNIEnv &env) { + // Lookup the class + javaClass = *jni::Class<Geometry>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<Geometry> Geometry::javaClass; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/geometry.hpp b/platform/android/src/geojson/geometry.hpp new file mode 100644 index 0000000000..bdcff6bb3e --- /dev/null +++ b/platform/android/src/geojson/geometry.hpp @@ -0,0 +1,27 @@ +#pragma once + +#include <mbgl/util/geojson.hpp> +#include <mbgl/util/noncopyable.hpp> + +#include <jni/jni.hpp> + +namespace mbgl { +namespace android { +namespace geojson { + +class Geometry : private mbgl::util::noncopyable { +public: + static constexpr auto Name() { return "com/mapbox/services/commons/geojson/Geometry"; }; + + static mapbox::geojson::geometry convert(jni::JNIEnv&, jni::Object<Geometry>); + + static std::string getType(jni::JNIEnv&, jni::Object<Geometry>); + + static jni::Class<Geometry> javaClass; + + static void registerNative(jni::JNIEnv&); +}; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/line_string.cpp b/platform/android/src/geojson/line_string.cpp new file mode 100644 index 0000000000..d0719f2538 --- /dev/null +++ b/platform/android/src/geojson/line_string.cpp @@ -0,0 +1,54 @@ +#include "line_string.hpp" + +#include "position.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + +mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, jni::Object<LineString> jLineString) { + mapbox::geojson::line_string lineString; + + if (jLineString) { + auto jPositionList = LineString::getCoordinates(env, jLineString); + lineString = LineString::convert(env, jPositionList); + jni::DeleteLocalRef(env, jPositionList); + } + + return lineString; +} + +mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, jni::Object<java::util::List/*<Position>*/> jPositionList) { + mapbox::geojson::line_string lineString; + + if (jPositionList) { + auto jPositionArray = java::util::List::toArray<Position>(env, jPositionList); + + auto size = jPositionArray.Length(env); + for (std::size_t i = 0; i < size; i++) { + auto jPosition = jPositionArray.Get(env, i); + lineString.push_back(Position::convert(env, jPosition)); + jni::DeleteLocalRef(env, jPosition); + } + + jni::DeleteLocalRef(env, jPositionArray); + } + + return lineString; +} + +jni::Object<java::util::List> LineString::getCoordinates(jni::JNIEnv &env, jni::Object<LineString> jLineString) { + static auto method = LineString::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "getCoordinates"); + return jLineString.Call(env, method); +} + +void LineString::registerNative(jni::JNIEnv &env) { + // Lookup the class + javaClass = *jni::Class<LineString>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<LineString> LineString::javaClass; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/line_string.hpp b/platform/android/src/geojson/line_string.hpp new file mode 100644 index 0000000000..d3be68d0a5 --- /dev/null +++ b/platform/android/src/geojson/line_string.hpp @@ -0,0 +1,34 @@ +#pragma once + +#include <mbgl/util/geojson.hpp> +#include <mbgl/util/noncopyable.hpp> + +#include <jni/jni.hpp> + +#include "../java/util.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + + +class LineString : private mbgl::util::noncopyable { +public: + static constexpr auto Name() { return "com/mapbox/services/commons/geojson/LineString"; }; + + static constexpr auto Type() { return "LineString"; }; + + static mapbox::geojson::line_string convert(jni::JNIEnv&, jni::Object<LineString>); + + static mapbox::geojson::line_string convert(jni::JNIEnv&, jni::Object<java::util::List/*<Position>*/>); + + static jni::Object<java::util::List> getCoordinates(jni::JNIEnv&, jni::Object<LineString>); + + static jni::Class<LineString> javaClass; + + static void registerNative(jni::JNIEnv&); +}; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/multi_line_string.cpp b/platform/android/src/geojson/multi_line_string.cpp new file mode 100644 index 0000000000..b676144bf5 --- /dev/null +++ b/platform/android/src/geojson/multi_line_string.cpp @@ -0,0 +1,56 @@ +#include "multi_line_string.hpp" + +#include "line_string.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + +mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv &env, jni::Object<MultiLineString> jMultiLineString) { + mapbox::geojson::multi_line_string multiLineString; + + if (jMultiLineString) { + auto jPositionListsList = MultiLineString::getCoordinates(env, jMultiLineString); + multiLineString = MultiLineString::convert(env, jPositionListsList); + jni::DeleteLocalRef(env, jPositionListsList); + } + + return multiLineString; +} + +mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv &env, jni::Object<java::util::List/*<java::util::List<Position>>*/> jPositionListsList) { + mapbox::geojson::multi_line_string multiLineString; + + if (jPositionListsList) { + auto jPositionListsArray = java::util::List::toArray<java::util::List>(env, jPositionListsList); + + auto size = jPositionListsArray.Length(env); + multiLineString.reserve(size); + + for (std::size_t i = 0; i < size; i++) { + auto jPositionList = jPositionListsArray.Get(env, i); + multiLineString.push_back(LineString::convert(env, jPositionList)); + jni::DeleteLocalRef(env, jPositionList); + } + + jni::DeleteLocalRef(env, jPositionListsArray); + } + + return multiLineString; +} + +jni::Object<java::util::List> MultiLineString::getCoordinates(jni::JNIEnv &env, jni::Object<MultiLineString> jLineString) { + static auto method = MultiLineString::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "getCoordinates"); + return jLineString.Call(env, method); +} + +void MultiLineString::registerNative(jni::JNIEnv &env) { + // Lookup the class + javaClass = *jni::Class<MultiLineString>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<MultiLineString> MultiLineString::javaClass; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/multi_line_string.hpp b/platform/android/src/geojson/multi_line_string.hpp new file mode 100644 index 0000000000..af33fe72d6 --- /dev/null +++ b/platform/android/src/geojson/multi_line_string.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include <mbgl/util/geojson.hpp> +#include <mbgl/util/noncopyable.hpp> + +#include <jni/jni.hpp> + +#include "../java/util.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + +class MultiLineString : private mbgl::util::noncopyable { +public: + static constexpr auto Name() { return "com/mapbox/services/commons/geojson/MultiLineString"; }; + + static constexpr auto Type() { return "MultiLineString"; }; + + static mapbox::geojson::multi_line_string convert(jni::JNIEnv&, jni::Object<MultiLineString>); + + static mapbox::geojson::multi_line_string convert(jni::JNIEnv&, jni::Object<java::util::List/*<java::util::List<Position>>*/>); + + static jni::Object<java::util::List> getCoordinates(jni::JNIEnv&, jni::Object<MultiLineString>); + + static jni::Class<MultiLineString> javaClass; + + static void registerNative(jni::JNIEnv&); +}; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/multi_point.cpp b/platform/android/src/geojson/multi_point.cpp new file mode 100644 index 0000000000..df4fdd7dfa --- /dev/null +++ b/platform/android/src/geojson/multi_point.cpp @@ -0,0 +1,35 @@ +#include "multi_point.hpp" + +#include "line_string.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + +mapbox::geojson::multi_point MultiPoint::convert(jni::JNIEnv &env, jni::Object<MultiPoint> jMultiPoint) { + mapbox::geojson::multi_point multiPoint; + + if (jMultiPoint) { + auto jPositionListsList = MultiPoint::getCoordinates(env, jMultiPoint); + multiPoint = LineString::convert(env, jPositionListsList); + jni::DeleteLocalRef(env, jPositionListsList); + } + + return multiPoint; +} + +jni::Object<java::util::List> MultiPoint::getCoordinates(jni::JNIEnv &env, jni::Object<MultiPoint> jMultiPoint) { + static auto method = MultiPoint::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "getCoordinates"); + return jMultiPoint.Call(env, method); +} + +void MultiPoint::registerNative(jni::JNIEnv &env) { + // Lookup the class + javaClass = *jni::Class<MultiPoint>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<MultiPoint> MultiPoint::javaClass; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/multi_point.hpp b/platform/android/src/geojson/multi_point.hpp new file mode 100644 index 0000000000..7a698287eb --- /dev/null +++ b/platform/android/src/geojson/multi_point.hpp @@ -0,0 +1,31 @@ +#pragma once + +#include <mbgl/util/geojson.hpp> +#include <mbgl/util/noncopyable.hpp> + +#include <jni/jni.hpp> + +#include "../java/util.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + +class MultiPoint : private mbgl::util::noncopyable { +public: + static constexpr auto Name() { return "com/mapbox/services/commons/geojson/MultiPoint"; }; + + static constexpr auto Type() { return "MultiPoint"; }; + + static mapbox::geojson::multi_point convert(jni::JNIEnv&, jni::Object<MultiPoint>); + + static jni::Object<java::util::List> getCoordinates(jni::JNIEnv&, jni::Object<MultiPoint>); + + static jni::Class<MultiPoint> javaClass; + + static void registerNative(jni::JNIEnv&); +}; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/multi_polygon.cpp b/platform/android/src/geojson/multi_polygon.cpp new file mode 100644 index 0000000000..a55884a110 --- /dev/null +++ b/platform/android/src/geojson/multi_polygon.cpp @@ -0,0 +1,46 @@ +#include "multi_polygon.hpp" + +#include "polygon.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + +mapbox::geojson::multi_polygon MultiPolygon::convert(jni::JNIEnv &env, jni::Object<MultiPolygon> jMultiPolygon) { + mapbox::geojson::multi_polygon multiPolygon; + + if (jMultiPolygon) { + auto jPositionListsListList = MultiPolygon::getCoordinates(env, jMultiPolygon); + auto jPositionListsListArray = java::util::List::toArray<java::util::List>(env, jPositionListsListList); + + auto size = jPositionListsListArray.Length(env); + multiPolygon.reserve(size); + + for (size_t i = 0; i < size; i++) { + auto jPositionListsList = jPositionListsListArray.Get(env, i); + multiPolygon.push_back(Polygon::convert(env, jPositionListsList)); + jni::DeleteLocalRef(env, jPositionListsList); + } + + jni::DeleteLocalRef(env, jPositionListsListList); + jni::DeleteLocalRef(env, jPositionListsListArray); + } + + return multiPolygon; +} + +jni::Object<java::util::List> MultiPolygon::getCoordinates(jni::JNIEnv &env, jni::Object<MultiPolygon> jPolygon) { + static auto method = MultiPolygon::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "getCoordinates"); + return jPolygon.Call(env, method); +} + +void MultiPolygon::registerNative(jni::JNIEnv &env) { + // Lookup the class + javaClass = *jni::Class<MultiPolygon>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<MultiPolygon> MultiPolygon::javaClass; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/multi_polygon.hpp b/platform/android/src/geojson/multi_polygon.hpp new file mode 100644 index 0000000000..1f144cffd2 --- /dev/null +++ b/platform/android/src/geojson/multi_polygon.hpp @@ -0,0 +1,31 @@ +#pragma once + +#include <mbgl/util/geojson.hpp> +#include <mbgl/util/noncopyable.hpp> + +#include <jni/jni.hpp> + +#include "../java/util.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + +class MultiPolygon : private mbgl::util::noncopyable { +public: + static constexpr auto Name() { return "com/mapbox/services/commons/geojson/MultiPolygon"; }; + + static constexpr auto Type() { return "MultiPolygon"; }; + + static mapbox::geojson::multi_polygon convert(jni::JNIEnv&, jni::Object<MultiPolygon>); + + static jni::Object<java::util::List> getCoordinates(jni::JNIEnv&, jni::Object<MultiPolygon>); + + static jni::Class<MultiPolygon> javaClass; + + static void registerNative(jni::JNIEnv&); +}; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/point.cpp b/platform/android/src/geojson/point.cpp new file mode 100644 index 0000000000..3d19a119d7 --- /dev/null +++ b/platform/android/src/geojson/point.cpp @@ -0,0 +1,28 @@ +#include "point.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + +mapbox::geojson::point Point::convert(jni::JNIEnv &env, jni::Object<Point> jPoint) { + auto jPosition = Point::getPosition(env, jPoint); + auto point = Position::convert(env, jPosition); + jni::DeleteLocalRef(env, jPosition); + return point; +} + +jni::Object<Position> Point::getPosition(JNIEnv& env, jni::Object<Point> jPoint) { + static auto method = Point::javaClass.GetMethod<jni::Object<Position> ()>(env, "getCoordinates"); + return jPoint.Call(env, method); +} + +void Point::registerNative(jni::JNIEnv &env) { + // Lookup the class + javaClass = *jni::Class<Point>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<Point> Point::javaClass; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/point.hpp b/platform/android/src/geojson/point.hpp new file mode 100644 index 0000000000..64ac0af9cc --- /dev/null +++ b/platform/android/src/geojson/point.hpp @@ -0,0 +1,31 @@ +#pragma once + +#include <mbgl/util/geojson.hpp> +#include <mbgl/util/noncopyable.hpp> + +#include "position.hpp" + +#include <jni/jni.hpp> + +namespace mbgl { +namespace android { +namespace geojson { + +class Point : private mbgl::util::noncopyable { +public: + static constexpr auto Name() { return "com/mapbox/services/commons/geojson/Point"; }; + + static constexpr auto Type() { return "Point"; }; + + static mapbox::geojson::point convert(jni::JNIEnv&, jni::Object<Point>); + + static jni::Object<Position> getPosition(JNIEnv&, jni::Object<Point>); + + static jni::Class<Point> javaClass; + + static void registerNative(jni::JNIEnv&); +}; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/polygon.cpp b/platform/android/src/geojson/polygon.cpp new file mode 100644 index 0000000000..bb37b8d99e --- /dev/null +++ b/platform/android/src/geojson/polygon.cpp @@ -0,0 +1,48 @@ +#include "polygon.hpp" + +#include "multi_line_string.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + +mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, jni::Object<Polygon> jPolygon) { + mapbox::geojson::polygon polygon; + + if (jPolygon) { + auto jPositionListsList = Polygon::getCoordinates(env, jPolygon); + polygon = Polygon::convert(env, jPositionListsList); + jni::DeleteLocalRef(env, jPositionListsList); + } + + return polygon; +} + +mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, jni::Object<java::util::List/*<java::util::List<Position>>*/> jPositionListsList) { + mapbox::geojson::polygon polygon; + + if (jPositionListsList) { + auto multiLine = MultiLineString::convert(env, jPositionListsList); + polygon.reserve(multiLine.size()); + polygon.insert(std::end(polygon), std::begin(multiLine), std::end(multiLine)); + } + + return polygon; +} + + +jni::Object<java::util::List> Polygon::getCoordinates(jni::JNIEnv &env, jni::Object<Polygon> jPolygon) { + static auto method = Polygon::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "getCoordinates"); + return jPolygon.Call(env, method); +} + +void Polygon::registerNative(jni::JNIEnv &env) { + // Lookup the class + javaClass = *jni::Class<Polygon>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<Polygon> Polygon::javaClass; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/polygon.hpp b/platform/android/src/geojson/polygon.hpp new file mode 100644 index 0000000000..e5362cedf1 --- /dev/null +++ b/platform/android/src/geojson/polygon.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include <mbgl/util/geojson.hpp> +#include <mbgl/util/noncopyable.hpp> + +#include <jni/jni.hpp> + +#include "../java/util.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + +class Polygon : private mbgl::util::noncopyable { +public: + static constexpr auto Name() { return "com/mapbox/services/commons/geojson/Polygon"; }; + + static constexpr auto Type() { return "Polygon"; }; + + static mapbox::geojson::polygon convert(jni::JNIEnv &, jni::Object<Polygon>); + + static mapbox::geojson::polygon convert(jni::JNIEnv&, jni::Object<java::util::List/*<java::util::List<Position>>*/>); + + static jni::Object<java::util::List> getCoordinates(jni::JNIEnv&, jni::Object<Polygon>); + + static jni::Class<Polygon> javaClass; + + static void registerNative(jni::JNIEnv &); +}; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/position.cpp b/platform/android/src/geojson/position.cpp new file mode 100644 index 0000000000..c0e6da3887 --- /dev/null +++ b/platform/android/src/geojson/position.cpp @@ -0,0 +1,27 @@ +#include "position.hpp" + +namespace mbgl { +namespace android { +namespace geojson { + +mapbox::geojson::point Position::convert(jni::JNIEnv &env, jni::Object<Position> jPosition) { + static auto method = Position::javaClass.GetMethod<jni::Array<jdouble> ()>(env, "getCoordinates"); + // Array with 0: longitude, 1: latitude (and optionally 2: altitude) + auto coordinates = jPosition.Call(env, method); + jdouble lngLat[2]; + coordinates.GetRegion(env, 0, lngLat); + mapbox::geojson::point point(lngLat[0], lngLat[1]); + jni::DeleteLocalRef(env, coordinates); + return point; +} + +void Position::registerNative(jni::JNIEnv &env) { + // Lookup the class + javaClass = *jni::Class<Position>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<Position> Position::javaClass; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geojson/position.hpp b/platform/android/src/geojson/position.hpp new file mode 100644 index 0000000000..7017a8172a --- /dev/null +++ b/platform/android/src/geojson/position.hpp @@ -0,0 +1,27 @@ +#pragma once + +#include <mbgl/util/geojson.hpp> +#include <mbgl/util/noncopyable.hpp> + +#include <jni/jni.hpp> + +namespace mbgl { +namespace android { +namespace geojson { + +class Position : private mbgl::util::noncopyable { +public: + static constexpr auto Name() { return "com/mapbox/services/commons/models/Position"; }; + + static constexpr auto Type() { return "Position"; }; + + static mapbox::geojson::point convert(jni::JNIEnv&, jni::Object<Position>); + + static jni::Class<Position> javaClass; + + static void registerNative(jni::JNIEnv&); +}; + +} // namespace geojson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geometry/feature.cpp b/platform/android/src/geometry/feature.cpp deleted file mode 100644 index 5355d50ab7..0000000000 --- a/platform/android/src/geometry/feature.cpp +++ /dev/null @@ -1,20 +0,0 @@ -#include "feature.hpp" - -namespace mbgl { -namespace android { - -jni::Object<Feature> Feature::fromGeometry(jni::JNIEnv& env, jni::Object<Geometry> geometry, jni::Object<JsonObject> properties, jni::String id) { - static auto method = Feature::javaClass.GetStaticMethod<jni::Object<Feature> (jni::Object<Geometry>, jni::Object<JsonObject>, jni::String)>(env, "fromGeometry"); - return Feature::javaClass.Call(env, method, geometry, properties, id); -} - -void Feature::registerNative(jni::JNIEnv& env) { - // Lookup the class - Feature::javaClass = *jni::Class<Feature>::Find(env).NewGlobalRef(env).release(); -} - -jni::Class<Feature> Feature::javaClass; - - -} // namespace android -} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/geometry/geometry.hpp b/platform/android/src/geometry/geometry.hpp deleted file mode 100644 index 5c8ae39181..0000000000 --- a/platform/android/src/geometry/geometry.hpp +++ /dev/null @@ -1,16 +0,0 @@ -#pragma once - -#include <mbgl/util/noncopyable.hpp> - -namespace mbgl { -namespace android { - -class Geometry : private mbgl::util::noncopyable { -public: - static constexpr auto Name() { return "com/mapbox/services/commons/geojson/Geometry"; }; - -}; - - -} // namespace android -} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/gson/json_array.cpp b/platform/android/src/gson/json_array.cpp new file mode 100644 index 0000000000..d91e323ac9 --- /dev/null +++ b/platform/android/src/gson/json_array.cpp @@ -0,0 +1,40 @@ +#include "json_array.hpp" + +#include "json_element.hpp" + +namespace mbgl { +namespace android { +namespace gson { + +std::vector<mapbox::geometry::value> JsonArray::convert(jni::JNIEnv &env, jni::Object<JsonArray> jsonArray) { + std::vector<mapbox::geometry::value> values; + + if (jsonArray) { + static auto getMethod = JsonArray::javaClass.GetMethod<jni::Object<JsonElement> (jni::jint)>(env, "get"); + static auto sizeMethod = JsonArray::javaClass.GetMethod<jni::jint ()>(env, "size"); + + int size = jsonArray.Call(env, sizeMethod); + values.reserve(uint(size)); + + for (int i = 0; i < size; i++) { + auto entry = jsonArray.Call(env, getMethod, i); + if (entry) { + values.push_back(JsonElement::convert(env, entry)); + } + jni::DeleteLocalRef(env, entry); + } + } + + return values; +} + +void JsonArray::registerNative(jni::JNIEnv &env) { + // Lookup the class + javaClass = *jni::Class<JsonArray>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<JsonArray> JsonArray::javaClass; + +} // namespace gson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/gson/json_array.hpp b/platform/android/src/gson/json_array.hpp new file mode 100644 index 0000000000..8571ad5dba --- /dev/null +++ b/platform/android/src/gson/json_array.hpp @@ -0,0 +1,25 @@ +#pragma once + +#include <mapbox/geometry.hpp> +#include <mbgl/util/noncopyable.hpp> + +#include <jni/jni.hpp> + +namespace mbgl { +namespace android { +namespace gson { + +class JsonArray : private mbgl::util::noncopyable { +public: + static constexpr auto Name() { return "com/google/gson/JsonArray"; }; + + static std::vector<mapbox::geometry::value> convert(JNIEnv&, jni::Object<JsonArray>); + + static jni::Class<JsonArray> javaClass; + + static void registerNative(jni::JNIEnv&); +}; + +} // namespace gson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/gson/json_element.cpp b/platform/android/src/gson/json_element.cpp new file mode 100644 index 0000000000..060b1e0fe2 --- /dev/null +++ b/platform/android/src/gson/json_element.cpp @@ -0,0 +1,62 @@ +#include "json_element.hpp" + +#include "json_array.hpp" +#include "json_object.hpp" +#include "json_primitive.hpp" + +#include <mapbox/geometry/feature.hpp> +#include <mapbox/variant.hpp> + +namespace mbgl { +namespace android { +namespace gson { + +mapbox::geometry::value JsonElement::convert(jni::JNIEnv &env, jni::Object<JsonElement> jsonElement) { + mapbox::geometry::value value; + + if (jsonElement) { + if (isJsonPrimitive(env, jsonElement)) { + auto primitive = JsonPrimitive::convert(env, jni::Cast(env, jsonElement, JsonPrimitive::javaClass)); + value = mapbox::util::apply_visitor([](auto t) { return mapbox::geometry::value { t }; }, primitive); + } else if (isJsonObject(env, jsonElement)) { + mapbox::geometry::property_map map = JsonObject::convert(env, jni::Cast(env, jsonElement, JsonObject::javaClass)); + value = mapbox::util::recursive_wrapper<std::unordered_map<std::string, mapbox::geometry::value>> { map } ; + } else if (isJsonArray(env, jsonElement)) { + value = JsonArray::convert(env, jni::Cast(env, jsonElement, JsonArray::javaClass)); + } else { + value = mapbox::geometry::null_value; + } + } + return value; +} + +bool JsonElement::isJsonObject(JNIEnv& env, jni::Object<JsonElement> jsonElement) { + static auto method = JsonElement::javaClass.GetMethod<jni::jboolean ()>(env, "isJsonObject"); + return jsonElement.Call(env, method); +} + +bool JsonElement::isJsonArray(JNIEnv& env, jni::Object<JsonElement> jsonElement) { + static auto method = JsonElement::javaClass.GetMethod<jni::jboolean ()>(env, "isJsonArray"); + return jsonElement.Call(env, method); +} + +bool JsonElement::isJsonPrimitive(JNIEnv& env, jni::Object<JsonElement> jsonElement) { + static auto method = JsonElement::javaClass.GetMethod<jni::jboolean ()>(env, "isJsonPrimitive"); + return jsonElement.Call(env, method); +} + +bool JsonElement::isJsonNull(JNIEnv& env, jni::Object<JsonElement> jsonElement) { + static auto method = JsonElement::javaClass.GetMethod<jni::jboolean ()>(env, "isJsonNull"); + return jsonElement.Call(env, method); +} + +void JsonElement::registerNative(jni::JNIEnv &env) { + // Lookup the class + javaClass = *jni::Class<JsonElement>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<JsonElement> JsonElement::javaClass; + +} // namespace gson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/gson/json_element.hpp b/platform/android/src/gson/json_element.hpp new file mode 100644 index 0000000000..7619350617 --- /dev/null +++ b/platform/android/src/gson/json_element.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include <mapbox/geometry.hpp> +#include <mbgl/util/noncopyable.hpp> + +#include <jni/jni.hpp> + +namespace mbgl { +namespace android { +namespace gson { + +class JsonElement : private mbgl::util::noncopyable { +public: + static constexpr auto Name() { return "com/google/gson/JsonElement"; }; + + static mapbox::geometry::value convert(JNIEnv&, jni::Object<JsonElement>); + + static bool isJsonObject(JNIEnv&, jni::Object<JsonElement>); + + static bool isJsonArray(JNIEnv&, jni::Object<JsonElement>); + + static bool isJsonPrimitive(JNIEnv&, jni::Object<JsonElement>); + + static bool isJsonNull(JNIEnv&, jni::Object<JsonElement>); + + static jni::Class<JsonElement> javaClass; + + static void registerNative(jni::JNIEnv&); +}; + +} // namespace gson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/gson/json_object.cpp b/platform/android/src/gson/json_object.cpp new file mode 100644 index 0000000000..a704dae9dd --- /dev/null +++ b/platform/android/src/gson/json_object.cpp @@ -0,0 +1,64 @@ +#include "json_object.hpp" + +#include "json_element.hpp" + +#include "../java/util.hpp" + +namespace mbgl { +namespace android { +namespace gson { + + +template <typename F> // void (jni::String, jni::Object<gson::JsonElement>) +static void iterateEntrySet(jni::JNIEnv& env, jni::Object<JsonObject> jsonObject, F callback) { + // Get Set<Map.Entry<String, JsonElement>> + static auto method = JsonObject::javaClass.GetMethod<jni::Object<java::util::Set> ()>(env, "entrySet"); + auto entrySet = jsonObject.Call(env, method); + jni::Array<jni::Object<java::util::Map::Entry>> entryArray = java::util::Set::toArray<java::util::Map::Entry>(env, entrySet); + + size_t size = entryArray.Length(env); + for (size_t i = 0; i < size; i++) { + auto entry = entryArray.Get(env, i); + if (entry) { + // Convert + auto jKey = java::util::Map::Entry::getKey<jni::ObjectTag>(env, entry); + auto jKeyString = jni::String(reinterpret_cast<jni::jstring*>(jKey.Get())); + auto jValue = java::util::Map::Entry::getValue<gson::JsonElement>(env, entry); + + // Callback + callback(jKeyString, jValue); + + // Cleanup + // Skip jKey as it points to the same as jKeyString + jni::DeleteLocalRef(env, jKeyString); + jni::DeleteLocalRef(env, jValue); + } + jni::DeleteLocalRef(env, entry); + } + + jni::DeleteLocalRef(env, entrySet); + jni::DeleteLocalRef(env, entryArray); +} + +mapbox::geometry::property_map JsonObject::convert(jni::JNIEnv &env, jni::Object<JsonObject> jsonObject) { + mapbox::geometry::property_map map; + + if (jsonObject) { + iterateEntrySet(env, jsonObject, [&map, &env](jni::String jId, jni::Object<gson::JsonElement> jsonElement) { + map[jni::Make<std::string>(env, jId)] = JsonElement::convert(env, jsonElement); + }); + } + + return map; +} + +void JsonObject::registerNative(jni::JNIEnv &env) { + // Lookup the class + javaClass = *jni::Class<JsonObject>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<JsonObject> JsonObject::javaClass; + +} // namespace gson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/gson/json_object.hpp b/platform/android/src/gson/json_object.hpp index a7de0b1978..aba8e40415 100644 --- a/platform/android/src/gson/json_object.hpp +++ b/platform/android/src/gson/json_object.hpp @@ -1,16 +1,25 @@ #pragma once +#include <mapbox/geometry.hpp> #include <mbgl/util/noncopyable.hpp> +#include <jni/jni.hpp> + namespace mbgl { namespace android { +namespace gson { class JsonObject : private mbgl::util::noncopyable { public: static constexpr auto Name() { return "com/google/gson/JsonObject"; }; -}; + static mapbox::geometry::property_map convert(JNIEnv&, jni::Object<JsonObject>); + static jni::Class<JsonObject> javaClass; + + static void registerNative(jni::JNIEnv&); +}; +} // namespace gson } // namespace android } // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/gson/json_primitive.cpp b/platform/android/src/gson/json_primitive.cpp new file mode 100644 index 0000000000..58d0b45fe7 --- /dev/null +++ b/platform/android/src/gson/json_primitive.cpp @@ -0,0 +1,66 @@ +#include "json_primitive.hpp" + +namespace mbgl { +namespace android { +namespace gson { + +JsonPrimitive::value JsonPrimitive::convert(jni::JNIEnv &env, jni::Object<JsonPrimitive> jsonPrimitive) { + value value; + if (jsonPrimitive) { + if (isBoolean(env, jsonPrimitive)) { + value = getAsBoolean(env, jsonPrimitive); + } else if (isNumber(env, jsonPrimitive)) { + //TODO: how to differentiate types here? + value = getAsDouble(env, jsonPrimitive); + } else if (isString(env, jsonPrimitive)) { + value = getAsString(env, jsonPrimitive); + } else { + value = mapbox::geometry::null_value; + } + } + return value; +} + +bool JsonPrimitive::isBoolean(JNIEnv& env, jni::Object<JsonPrimitive> jsonPrimitive) { + static auto method = JsonPrimitive::javaClass.GetMethod<jni::jboolean ()>(env, "isBoolean"); + return jsonPrimitive.Call(env, method); +} + +bool JsonPrimitive::isString(JNIEnv& env, jni::Object<JsonPrimitive> jsonPrimitive) { + static auto method = JsonPrimitive::javaClass.GetMethod<jni::jboolean ()>(env, "isString"); + return jsonPrimitive.Call(env, method); +} + +bool JsonPrimitive::isNumber(JNIEnv& env, jni::Object<JsonPrimitive> jsonPrimitive) { + static auto method = JsonPrimitive::javaClass.GetMethod<jni::jboolean ()>(env, "isNumber"); + return jsonPrimitive.Call(env, method); +} + +bool JsonPrimitive::getAsBoolean(JNIEnv& env, jni::Object<JsonPrimitive> jsonPrimitive) { + static auto method = JsonPrimitive::javaClass.GetMethod<jni::jboolean ()>(env, "getAsBoolean"); + return jsonPrimitive.Call(env, method); +} + +std::string JsonPrimitive::getAsString(JNIEnv& env, jni::Object<JsonPrimitive> jsonPrimitive) { + static auto method = JsonPrimitive::javaClass.GetMethod<jni::String ()>(env, "getAsString"); + auto jString = jsonPrimitive.Call(env, method); + auto string = jni::Make<std::string>(env, jString); + jni::DeleteLocalRef(env, jString); + return string; +} + +double JsonPrimitive::getAsDouble(JNIEnv& env, jni::Object<JsonPrimitive> jsonPrimitive) { + static auto method = JsonPrimitive::javaClass.GetMethod<jni::jdouble ()>(env, "getAsDouble"); + return jsonPrimitive.Call(env, method); +} + +void JsonPrimitive::registerNative(jni::JNIEnv &env) { + // Lookup the class + javaClass = *jni::Class<JsonPrimitive>::Find(env).NewGlobalRef(env).release(); +} + +jni::Class<JsonPrimitive> JsonPrimitive::javaClass; + +} // namespace gson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/gson/json_primitive.hpp b/platform/android/src/gson/json_primitive.hpp new file mode 100644 index 0000000000..5fc8a2b485 --- /dev/null +++ b/platform/android/src/gson/json_primitive.hpp @@ -0,0 +1,39 @@ +#pragma once + +#include <mapbox/geometry.hpp> +#include <mbgl/util/noncopyable.hpp> + +#include <jni/jni.hpp> + +namespace mbgl { +namespace android { +namespace gson { + +class JsonPrimitive : private mbgl::util::noncopyable { +public: + using value = mapbox::util::variant<mapbox::geometry::null_value_t, bool, uint64_t, int64_t, double, std::string>; + + static constexpr auto Name() { return "com/google/gson/JsonPrimitive"; }; + + static value convert(JNIEnv&, jni::Object<JsonPrimitive>); + + static bool isBoolean(JNIEnv&, jni::Object<JsonPrimitive>); + + static bool isString(JNIEnv&, jni::Object<JsonPrimitive>); + + static bool isNumber(JNIEnv&, jni::Object<JsonPrimitive>); + + static bool getAsBoolean(JNIEnv&, jni::Object<JsonPrimitive>); + + static std::string getAsString(JNIEnv&, jni::Object<JsonPrimitive>); + + static double getAsDouble(JNIEnv&, jni::Object<JsonPrimitive>); + + static jni::Class<JsonPrimitive> javaClass; + + static void registerNative(jni::JNIEnv&); +}; + +} // namespace gson +} // namespace android +} // namespace mbgl
\ No newline at end of file diff --git a/platform/android/src/java/util.cpp b/platform/android/src/java/util.cpp index c630e403d9..effd2ae0d0 100644 --- a/platform/android/src/java/util.cpp +++ b/platform/android/src/java/util.cpp @@ -6,9 +6,15 @@ namespace java { namespace util { jni::Class<List> List::javaClass; +jni::Class<Set> Set::javaClass; +jni::Class<Map> Map::javaClass; +jni::Class<Map::Entry> Map::Entry::javaClass; void registerNative(jni::JNIEnv& env) { List::javaClass = *jni::Class<List>::Find(env).NewGlobalRef(env).release(); + Set::javaClass = *jni::Class<Set>::Find(env).NewGlobalRef(env).release(); + Map::javaClass = *jni::Class<Map>::Find(env).NewGlobalRef(env).release(); + Map::Entry::javaClass = *jni::Class<Map::Entry>::Find(env).NewGlobalRef(env).release(); } diff --git a/platform/android/src/java/util.hpp b/platform/android/src/java/util.hpp index 1a552c7124..dedb8ac348 100644 --- a/platform/android/src/java/util.hpp +++ b/platform/android/src/java/util.hpp @@ -24,6 +24,48 @@ public: }; +class Set : private mbgl::util::noncopyable { +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 toArray = Set::javaClass.GetMethod<jni::Array<jni::Object<>> ()>(env, "toArray"); + return (jni::Array<jni::Object<T>>) list.Call(env, toArray); + }; + + static jni::Class<Set> javaClass; + +}; + +class Map : private mbgl::util::noncopyable { +public: + + class Entry : private mbgl::util::noncopyable { + 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 method = Entry::javaClass.GetMethod<jni::Object<> ()>(env, "getKey"); + return (jni::Object<T>) entry.Call(env, method); + } + + template <class T> + static jni::Object<T> getValue(jni::JNIEnv& env, jni::Object<Entry> entry) { + static auto method = Entry::javaClass.GetMethod<jni::Object<> ()>(env, "getValue"); + return (jni::Object<T>) entry.Call(env, method).Get(); + } + + static jni::Class<Entry> javaClass; + }; + + static constexpr auto Name() { return "java/util/Map"; }; + + static jni::Class<Map> javaClass; +}; + void registerNative(jni::JNIEnv&); diff --git a/platform/android/src/jni.cpp b/platform/android/src/jni.cpp index bd12cff3fa..54cb0867d0 100755 --- a/platform/android/src/jni.cpp +++ b/platform/android/src/jni.cpp @@ -11,12 +11,25 @@ #include "conversion/conversion.hpp" #include "conversion/collection.hpp" #include "file_source.hpp" -#include "geometry/feature.hpp" +#include "geojson/feature.hpp" +#include "geojson/feature_collection.hpp" +#include "geojson/geometry.hpp" +#include "geojson/line_string.hpp" +#include "geojson/multi_line_string.hpp" +#include "geojson/multi_point.hpp" +#include "geojson/multi_polygon.hpp" +#include "geojson/point.hpp" +#include "geojson/polygon.hpp" +#include "geojson/position.hpp" #include "geometry/lat_lng.hpp" #include "geometry/lat_lng_bounds.hpp" #include "geometry/projected_meters.hpp" #include "graphics/pointf.hpp" #include "graphics/rectf.hpp" +#include "gson/json_array.hpp" +#include "gson/json_element.hpp" +#include "gson/json_object.hpp" +#include "gson/json_primitive.hpp" #include "java_types.hpp" #include "native_map_view.hpp" #include "offline/offline_manager.hpp" @@ -97,12 +110,29 @@ void registerNatives(JavaVM *vm) { PointF::registerNative(env); RectF::registerNative(env); + // GeoJSON + geojson::Feature::registerNative(env); + geojson::FeatureCollection::registerNative(env); + geojson::Geometry::registerNative(env); + geojson::LineString::registerNative(env); + geojson::MultiLineString::registerNative(env); + geojson::MultiPoint::registerNative(env); + geojson::MultiPolygon::registerNative(env); + geojson::Point::registerNative(env); + geojson::Polygon::registerNative(env); + geojson::Position::registerNative(env); + // Geometry - Feature::registerNative(env); LatLng::registerNative(env); LatLngBounds::registerNative(env); ProjectedMeters::registerNative(env); + // GSon + gson::JsonArray::registerNative(env); + gson::JsonElement::registerNative(env); + gson::JsonObject::registerNative(env); + gson::JsonPrimitive::registerNative(env); + //Annotation Marker::registerNative(env); Polygon::registerNative(env); diff --git a/platform/android/src/native_map_view.cpp b/platform/android/src/native_map_view.cpp index 4547eeff21..f1345c01f9 100755 --- a/platform/android/src/native_map_view.cpp +++ b/platform/android/src/native_map_view.cpp @@ -35,7 +35,7 @@ #include "conversion/conversion.hpp" #include "conversion/collection.hpp" #include "style/conversion/filter.hpp" -#include "geometry/conversion/feature.hpp" +#include "geojson/conversion/feature.hpp" #include "jni.hpp" #include "attach_env.hpp" @@ -793,32 +793,35 @@ jni::Array<jlong> NativeMapView::queryPointAnnotations(JNIEnv& env, jni::Object< return result; } -jni::Array<jni::Object<Feature>> NativeMapView::queryRenderedFeaturesForPoint(JNIEnv& env, jni::jfloat x, jni::jfloat y, +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) { using namespace mbgl::android::conversion; - using namespace mapbox::geometry; + using namespace mbgl::android::geojson; mbgl::optional<std::vector<std::string>> layers; if (layerIds != nullptr && layerIds.Length(env) > 0) { layers = android::conversion::toVector(env, layerIds); } - point<double> point = {x, y}; + mapbox::geometry::point<double> point = {x, y}; return *convert<jni::Array<jni::Object<Feature>>, std::vector<mbgl::Feature>>(env, map->queryRenderedFeatures(point, { layers, toFilter(env, jfilter) })); } -jni::Array<jni::Object<Feature>> NativeMapView::queryRenderedFeaturesForBox(JNIEnv& env, jni::jfloat left, jni::jfloat top, +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) { using namespace mbgl::android::conversion; - using namespace mapbox::geometry; + using namespace mbgl::android::geojson; mbgl::optional<std::vector<std::string>> layers; if (layerIds != nullptr && layerIds.Length(env) > 0) { layers = toVector(env, layerIds); } - box<double> box = { point<double>{ left, top}, point<double>{ right, bottom } }; + mapbox::geometry::box<double> box = { + mapbox::geometry::point<double>{ left, top}, + mapbox::geometry::point<double>{ right, bottom } + }; return *convert<jni::Array<jni::Object<Feature>>, std::vector<mbgl::Feature>>(env, map->queryRenderedFeatures(box, { layers, toFilter(env, jfilter) })); } diff --git a/platform/android/src/native_map_view.hpp b/platform/android/src/native_map_view.hpp index 4651ed81e7..d48d5a107c 100755 --- a/platform/android/src/native_map_view.hpp +++ b/platform/android/src/native_map_view.hpp @@ -17,7 +17,7 @@ #include "annotation/polyline.hpp" #include "graphics/pointf.hpp" #include "graphics/rectf.hpp" -#include "geometry/feature.hpp" +#include "geojson/feature.hpp" #include "geometry/lat_lng.hpp" #include "geometry/projected_meters.hpp" #include "style/layers/layers.hpp" @@ -222,11 +222,11 @@ public: jni::Array<jlong> queryPointAnnotations(JNIEnv&, jni::Object<RectF>); - jni::Array<jni::Object<Feature>> queryRenderedFeaturesForPoint(JNIEnv&, jni::jfloat, jni::jfloat, + jni::Array<jni::Object<geojson::Feature>> queryRenderedFeaturesForPoint(JNIEnv&, jni::jfloat, jni::jfloat, jni::Array<jni::String>, jni::Array<jni::Object<>> jfilter); - jni::Array<jni::Object<Feature>> queryRenderedFeaturesForBox(JNIEnv&, jni::jfloat, jni::jfloat, jni::jfloat, + 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); diff --git a/platform/android/src/style/conversion/geojson.hpp b/platform/android/src/style/conversion/geojson.hpp index db474e8542..32a473b092 100644 --- a/platform/android/src/style/conversion/geojson.hpp +++ b/platform/android/src/style/conversion/geojson.hpp @@ -1,11 +1,8 @@ #pragma once -#include "../value.hpp" - #include <mapbox/geojson.hpp> #include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion/geojson.hpp> -#include <mbgl/util/logging.hpp> #include <jni/jni.hpp> namespace mbgl { @@ -14,14 +11,13 @@ namespace conversion { template <> optional<GeoJSON> convertGeoJSON(const mbgl::android::Value& value, Error& error) { - // Value should be a string wrapped in an object - mbgl::android::Value jsonValue = value.get("data"); - if(value.isNull()) { + + if(value.isNull() || !value.isString()) { error = { "no json data found" }; return {}; } - return convertGeoJSON(value.get("data").toString(), error); + return convertGeoJSON(value.toString(), error); } template <> diff --git a/platform/android/src/style/sources/geojson_source.cpp b/platform/android/src/style/sources/geojson_source.cpp index 0c2d25f9fc..ad55889858 100644 --- a/platform/android/src/style/sources/geojson_source.cpp +++ b/platform/android/src/style/sources/geojson_source.cpp @@ -8,8 +8,8 @@ // C++ -> Java conversion #include "../../conversion/conversion.hpp" #include "../../conversion/collection.hpp" -#include "../../geometry/conversion/feature.hpp" - +#include "../../geojson/conversion/feature.hpp" +#include "../conversion/url_or_tileset.hpp" #include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion/geojson_options.hpp> @@ -47,7 +47,7 @@ namespace android { GeoJSONSource::~GeoJSONSource() = default; - void GeoJSONSource::setGeoJSON(jni::JNIEnv& env, jni::Object<> json) { + void GeoJSONSource::setGeoJSONString(jni::JNIEnv& env, jni::String json) { using namespace mbgl::style::conversion; // Convert the jni object @@ -62,15 +62,25 @@ namespace android { source.as<mbgl::style::GeoJSONSource>()->GeoJSONSource::setGeoJSON(*converted); } + void GeoJSONSource::setFeatureCollection(jni::JNIEnv& env, jni::Object<geojson::FeatureCollection> jFeatures) { + using namespace mbgl::android::geojson; + + // Convert the jni object + auto features = FeatureCollection::convert(env, jFeatures); + + // Update the core source + source.as<mbgl::style::GeoJSONSource>()->GeoJSONSource::setGeoJSON(GeoJSON(features)); + } + void GeoJSONSource::setURL(jni::JNIEnv& env, jni::String url) { // Update the core source source.as<mbgl::style::GeoJSONSource>()->GeoJSONSource::setURL(jni::Make<std::string>(env, url)); } - jni::Array<jni::Object<Feature>> GeoJSONSource::querySourceFeatures(jni::JNIEnv& env, + jni::Array<jni::Object<geojson::Feature>> GeoJSONSource::querySourceFeatures(jni::JNIEnv& env, jni::Array<jni::Object<>> jfilter) { using namespace mbgl::android::conversion; - using namespace mapbox::geometry; + using namespace mbgl::android::geojson; auto filter = toFilter(env, jfilter); auto features = source.querySourceFeatures({ {}, filter }); @@ -96,7 +106,8 @@ namespace android { std::make_unique<GeoJSONSource, JNIEnv&, jni::String, jni::Object<>>, "initialize", "finalize", - METHOD(&GeoJSONSource::setGeoJSON, "nativeSetGeoJson"), + METHOD(&GeoJSONSource::setGeoJSONString, "nativeSetGeoJsonString"), + METHOD(&GeoJSONSource::setFeatureCollection, "nativeSetFeatureCollection"), METHOD(&GeoJSONSource::setURL, "nativeSetUrl"), METHOD(&GeoJSONSource::querySourceFeatures, "querySourceFeatures") ); diff --git a/platform/android/src/style/sources/geojson_source.hpp b/platform/android/src/style/sources/geojson_source.hpp index 5b529fc52a..98d98e26b3 100644 --- a/platform/android/src/style/sources/geojson_source.hpp +++ b/platform/android/src/style/sources/geojson_source.hpp @@ -2,7 +2,8 @@ #include "source.hpp" #include <mbgl/style/sources/geojson_source.hpp> -#include "../../geometry/feature.hpp" +#include "../../geojson/feature.hpp" +#include "../../geojson/feature_collection.hpp" #include <jni/jni.hpp> namespace mbgl { @@ -23,11 +24,14 @@ public: ~GeoJSONSource(); - void setGeoJSON(jni::JNIEnv&, jni::Object<>); + void setGeoJSONString(jni::JNIEnv&, jni::String); + + void setFeatureCollection(jni::JNIEnv&, jni::Object<geojson::FeatureCollection>); void setURL(jni::JNIEnv&, jni::String); - jni::Array<jni::Object<Feature>> querySourceFeatures(jni::JNIEnv&, jni::Array<jni::Object<>> jfilter); + jni::Array<jni::Object<geojson::Feature>> querySourceFeatures(jni::JNIEnv&, + jni::Array<jni::Object<>> jfilter); jni::jobject* createJavaPeer(jni::JNIEnv&); diff --git a/platform/android/src/style/sources/vector_source.cpp b/platform/android/src/style/sources/vector_source.cpp index 4852a9b84f..53aa144450 100644 --- a/platform/android/src/style/sources/vector_source.cpp +++ b/platform/android/src/style/sources/vector_source.cpp @@ -7,7 +7,7 @@ // C++ -> Java conversion #include "../../conversion/conversion.hpp" #include "../../conversion/collection.hpp" -#include "../../geometry/conversion/feature.hpp" +#include "../../geojson/conversion/feature.hpp" #include "../conversion/url_or_tileset.hpp" #include <mbgl/util/variant.hpp> @@ -34,11 +34,11 @@ namespace android { VectorSource::~VectorSource() = default; - jni::Array<jni::Object<Feature>> VectorSource::querySourceFeatures(jni::JNIEnv& env, + jni::Array<jni::Object<geojson::Feature>> VectorSource::querySourceFeatures(jni::JNIEnv& env, jni::Array<jni::String> jSourceLayerIds, jni::Array<jni::Object<>> jfilter) { using namespace mbgl::android::conversion; - using namespace mapbox::geometry; + using namespace mbgl::android::geojson; mbgl::optional<std::vector<std::string>> sourceLayerIds = { toVector(env, jSourceLayerIds) }; auto filter = toFilter(env, jfilter); diff --git a/platform/android/src/style/sources/vector_source.hpp b/platform/android/src/style/sources/vector_source.hpp index f7e7645c5b..cac687bb6f 100644 --- a/platform/android/src/style/sources/vector_source.hpp +++ b/platform/android/src/style/sources/vector_source.hpp @@ -2,7 +2,7 @@ #include "source.hpp" #include <mbgl/style/sources/vector_source.hpp> -#include "../../geometry/feature.hpp" +#include "../../geojson/feature.hpp" #include <jni/jni.hpp> namespace mbgl { @@ -23,8 +23,8 @@ public: ~VectorSource(); - jni::Array<jni::Object<Feature>> querySourceFeatures(jni::JNIEnv&, jni::Array<jni::String>, - jni::Array<jni::Object<>> jfilter); + jni::Array<jni::Object<geojson::Feature>> querySourceFeatures(jni::JNIEnv&, jni::Array<jni::String>, + jni::Array<jni::Object<>> jfilter); jni::jobject* createJavaPeer(jni::JNIEnv&); diff --git a/platform/android/src/style/value.cpp b/platform/android/src/style/value.cpp index da953c14be..e1cd81d7fd 100644 --- a/platform/android/src/style/value.cpp +++ b/platform/android/src/style/value.cpp @@ -22,7 +22,7 @@ namespace android { // Instance - Value::Value(jni::JNIEnv& env, jni::jobject* _value) : jenv(env), value(_value, ObjectDeleter(env)) {} + Value::Value(jni::JNIEnv& _env, jni::jobject* _value) : env(_env), value(_value, ObjectDeleter(env)) {} Value::~Value() = default; @@ -31,59 +31,59 @@ namespace android { } bool Value::isArray() const { - return jni::IsInstanceOf(jenv, value.get(), *java::ObjectArray::jclass); + return jni::IsInstanceOf(env, value.get(), *java::ObjectArray::jclass); } bool Value::isObject() const { - return jni::IsInstanceOf(jenv, value.get(), *java::Map::jclass);; + return jni::IsInstanceOf(env, value.get(), *java::Map::jclass);; } bool Value::isString() const { - return jni::IsInstanceOf(jenv, value.get(), *java::String::jclass); + return jni::IsInstanceOf(env, value.get(), *java::String::jclass); } bool Value::isBool() const { - return jni::IsInstanceOf(jenv, value.get(), *java::Boolean::jclass); + return jni::IsInstanceOf(env, value.get(), *java::Boolean::jclass); } bool Value::isNumber() const { - return jni::IsInstanceOf(jenv, value.get(), *java::Number::jclass); + return jni::IsInstanceOf(env, value.get(), *java::Number::jclass); } std::string Value::toString() const { jni::jstring* string = reinterpret_cast<jni::jstring*>(value.get()); - return jni::Make<std::string>(jenv, jni::String(string)); + return jni::Make<std::string>(env, jni::String(string)); } float Value::toFloat() const { - return jni::CallMethod<jni::jfloat>(jenv, value.get(), *java::Number::floatValueMethodId); + return jni::CallMethod<jni::jfloat>(env, value.get(), *java::Number::floatValueMethodId); } double Value::toDouble() const { - return jni::CallMethod<jni::jdouble>(jenv, value.get(), *java::Number::doubleValueMethodId); + return jni::CallMethod<jni::jdouble>(env, value.get(), *java::Number::doubleValueMethodId); } long Value::toLong() const { - return jni::CallMethod<jni::jlong>(jenv, value.get(), *java::Number::longValueMethodId); + return jni::CallMethod<jni::jlong>(env, value.get(), *java::Number::longValueMethodId); } bool Value::toBool() const { - return jni::CallMethod<jni::jboolean>(jenv, value.get(), *java::Boolean::booleanValueMethodId); + return jni::CallMethod<jni::jboolean>(env, value.get(), *java::Boolean::booleanValueMethodId); } Value Value::get(const char* key) const { - jni::jobject* member = jni::CallMethod<jni::jobject*>(jenv, value.get(), *java::Map::getMethodId, jni::Make<jni::String>(jenv, std::string(key)).Get()); - return Value(jenv, member); + jni::jobject* member = jni::CallMethod<jni::jobject*>(env, value.get(), *java::Map::getMethodId, jni::Make<jni::String>(env, std::string(key)).Get()); + return Value(env, member); } int Value::getLength() const { auto array = (jni::jarray<jni::jobject>*) value.get(); - return jni::GetArrayLength(jenv, *array); + return jni::GetArrayLength(env, *array); } - Value Value::get(const int index ) const { + Value Value::get(const int index) const { auto array = (jni::jarray<jni::jobject>*) value.get(); - return Value(jenv, jni::GetObjectArrayElement(jenv, *array, index)); + return Value(env, jni::GetObjectArrayElement(env, *array, index)); } } } diff --git a/platform/android/src/style/value.hpp b/platform/android/src/style/value.hpp index 761ce4d730..7464bae832 100644 --- a/platform/android/src/style/value.hpp +++ b/platform/android/src/style/value.hpp @@ -29,9 +29,7 @@ public: int getLength() const; Value get(const int index ) const; -private: - - jni::JNIEnv& jenv; + jni::JNIEnv& env; std::shared_ptr<jni::jobject> value; }; |