tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

migrated to use mapbox-java3.0

Browse Source 
migrated to use mapbox-java3.0
note that old 2.2.9 telementry is still used though
This commit is contained in:
Osana Babayan
2018-02-08 08:44:24 -05:00
committed by GitHub
parent 2ed069cb0a
commit 4498917a3b
46 changed files with 284 additions and 314 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapboxMap.java
View File

@@ -16,6 +16,8 @@ import android.text.TextUtils;
import android.view.View;
import android.view.ViewGroup;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.Geometry;
import com.mapbox.mapboxsdk.annotations.Annotation;
import com.mapbox.mapboxsdk.annotations.BaseMarkerOptions;
import com.mapbox.mapboxsdk.annotations.BaseMarkerViewOptions;
@@ -42,8 +44,6 @@ import com.mapbox.mapboxsdk.style.layers.Layer;
import com.mapbox.mapboxsdk.style.light.Light;
import com.mapbox.mapboxsdk.style.sources.Source;
import com.mapbox.services.android.telemetry.location.LocationEngine;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.Geometry;
import java.lang.reflect.ParameterizedType;
import java.util.HashMap;

4
platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/NativeMapView.java
View File

@@ -11,6 +11,8 @@ import android.support.annotation.Nullable;
import android.text.TextUtils;
import android.util.DisplayMetrics;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.Geometry;
import com.mapbox.mapboxsdk.LibraryLoader;
import com.mapbox.mapboxsdk.annotations.Icon;
import com.mapbox.mapboxsdk.annotations.Marker;
@@ -29,8 +31,6 @@ import com.mapbox.mapboxsdk.style.light.Light;
import com.mapbox.mapboxsdk.style.sources.CannotAddSourceException;
import com.mapbox.mapboxsdk.style.sources.Source;
import com.mapbox.mapboxsdk.utils.BitmapUtils;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.Geometry;
import java.nio.ByteBuffer;
import java.util.ArrayList;

4
platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/sources/CustomGeometrySource.java
View File

@@ -5,10 +5,10 @@ import android.support.annotation.Nullable;
import android.support.annotation.UiThread;
import android.support.annotation.WorkerThread;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.FeatureCollection;
import com.mapbox.mapboxsdk.geometry.LatLngBounds;
import com.mapbox.mapboxsdk.style.layers.Filter;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.FeatureCollection;
import java.lang.ref.WeakReference;
import java.util.ArrayList;

6
platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/sources/GeoJsonSource.java
View File

@@ -4,10 +4,10 @@ import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.UiThread;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.FeatureCollection;
import com.mapbox.geojson.Geometry;
import com.mapbox.mapboxsdk.style.layers.Filter;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.FeatureCollection;
import com.mapbox.services.commons.geojson.Geometry;
import java.net.URL;
import java.util.ArrayList;

2
platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/sources/GeometryTileProvider.java
View File

@@ -2,8 +2,8 @@ package com.mapbox.mapboxsdk.style.sources;
import android.support.annotation.WorkerThread;
import com.mapbox.geojson.FeatureCollection;
import com.mapbox.mapboxsdk.geometry.LatLngBounds;
import com.mapbox.services.commons.geojson.FeatureCollection;
/**
* Interface that defines methods for working with {@link CustomGeometrySource}.

2
platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/sources/VectorSource.java
View File

@@ -5,8 +5,8 @@ import android.support.annotation.Nullable;
import android.support.annotation.Size;
import android.support.annotation.UiThread;
import com.mapbox.geojson.Feature;
import com.mapbox.mapboxsdk.style.layers.Filter;
import com.mapbox.services.commons.geojson.Feature;
import java.net.URL;
import java.util.ArrayList;

2
platform/android/MapboxGLAndroidSDKTestApp/build.gradle
View File

@@ -57,6 +57,8 @@ dependencies {
transitive = true
}
api dependenciesList.mapboxJavaTurf
implementation dependenciesList.supportAppcompatV7
implementation dependenciesList.supportRecyclerView
implementation dependenciesList.supportDesign

8
platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/GeoJsonSourceTests.java
View File

@@ -13,9 +13,9 @@ import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.mapboxsdk.testapp.activity.BaseActivityTest;
import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity;
import com.mapbox.mapboxsdk.testapp.utils.ResourceUtils;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.FeatureCollection;
import com.mapbox.services.commons.geojson.Point;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.FeatureCollection;
import com.mapbox.geojson.Point;
import org.hamcrest.Matcher;
import org.junit.Test;
@@ -67,7 +67,7 @@ public class GeoJsonSourceTests extends BaseActivityTest {
@Override
public void perform(UiController uiController, View view) {
GeoJsonSource source = new GeoJsonSource("source", Point.fromCoordinates(new double[] {0d, 0d}));
GeoJsonSource source = new GeoJsonSource("source", Point.fromLngLat(0d, 0d));
mapboxMap.addSource(source);
mapboxMap.addLayer(new CircleLayer("layer", source.getId()));

8
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/AnimatedMarkerActivity.java
View File

@@ -12,6 +12,7 @@ import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.view.animation.AccelerateDecelerateInterpolator;
import com.mapbox.geojson.Point;
import com.mapbox.mapboxsdk.annotations.Icon;
import com.mapbox.mapboxsdk.annotations.IconFactory;
import com.mapbox.mapboxsdk.annotations.Marker;
@@ -25,8 +26,7 @@ import com.mapbox.mapboxsdk.maps.MapView;
import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.mapboxsdk.testapp.utils.IconUtils;
import com.mapbox.services.api.utils.turf.TurfMeasurement;
import com.mapbox.services.commons.models.Position;
import com.mapbox.turf.TurfMeasurement;
import java.util.ArrayList;
import java.util.List;
@@ -272,8 +272,8 @@ public class AnimatedMarkerActivity extends AppCompatActivity {
private double getBearing(LatLng from, LatLng to) {
return TurfMeasurement.bearing(
Position.fromCoordinates(from.getLongitude(), from.getLatitude()),
Position.fromCoordinates(to.getLongitude(), to.getLatitude())
Point.fromLngLat(from.getLongitude(), from.getLatitude()),
Point.fromLngLat(to.getLongitude(), to.getLatitude())
);
}

12
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/feature/QueryRenderedFeaturesBoxCountActivity.java
View File

@@ -7,10 +7,10 @@ import android.view.View;
import android.widget.Toast;
import com.google.gson.JsonElement;
import com.mapbox.geojson.Feature;
import com.mapbox.mapboxsdk.maps.MapView;
import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.services.commons.geojson.Feature;
import java.util.List;
import java.util.Map;
@@ -62,12 +62,12 @@ public class QueryRenderedFeaturesBoxCountActivity extends AppCompatActivity {
for (Feature feature : features) {
if (feature != null) {
Timber.i("Got feature %s with %s properties and Geometry %s",
feature.getId(),
feature.getProperties() != null ? feature.getProperties().entrySet().size() : "<null>",
feature.getGeometry() != null ? feature.getGeometry().getClass().getSimpleName() : "<null>"
feature.id(),
feature.properties() != null ? feature.properties().entrySet().size() : "<null>",
feature.geometry() != null ? feature.geometry().getClass().getSimpleName() : "<null>"
);
if (feature.getProperties() != null) {
for (Map.Entry<String, JsonElement> entry : feature.getProperties().entrySet()) {
if (feature.properties() != null) {
for (Map.Entry<String, JsonElement> entry : feature.properties().entrySet()) {
Timber.i("Prop %s - %s", entry.getKey(), entry.getValue());
}
}

5
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/feature/QueryRenderedFeaturesBoxHighlightActivity.java
View File

@@ -7,14 +7,15 @@ import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Toast;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.FeatureCollection;
import com.mapbox.mapboxsdk.maps.MapView;
import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.style.layers.FillLayer;
import com.mapbox.mapboxsdk.style.layers.Filter;
import com.mapbox.mapboxsdk.style.sources.GeoJsonSource;
import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.FeatureCollection;
import java.util.List;

2
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/feature/QueryRenderedFeaturesBoxSymbolCountActivity.java
View File

@@ -7,13 +7,13 @@ import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Toast;
import com.mapbox.geojson.Feature;
import com.mapbox.mapboxsdk.maps.MapView;
import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.style.layers.SymbolLayer;
import com.mapbox.mapboxsdk.style.sources.GeoJsonSource;
import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.mapboxsdk.testapp.utils.ResourceUtils;
import com.mapbox.services.commons.geojson.Feature;
import java.io.IOException;
import java.util.List;

15
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/feature/QueryRenderedFeaturesPropertiesActivity.java
View File

@@ -12,12 +12,13 @@ import android.widget.LinearLayout;
import android.widget.TextView;
import com.google.gson.JsonElement;
import com.mapbox.geojson.Feature;
import com.mapbox.mapboxsdk.annotations.BaseMarkerOptions;
import com.mapbox.mapboxsdk.annotations.Marker;
import com.mapbox.mapboxsdk.maps.MapView;
import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.services.commons.geojson.Feature;
import java.util.List;
import java.util.Map;
@@ -80,12 +81,12 @@ public class QueryRenderedFeaturesPropertiesActivity extends AppCompatActivity {
for (Feature feature : features) {
if (feature != null) {
Timber.i("Got feature %s with %s properties and Geometry %s",
feature.getId(),
feature.getProperties() != null ? feature.getProperties().entrySet().size() : "<null>",
feature.getGeometry() != null ? feature.getGeometry().getClass().getSimpleName() : "<null>"
feature.id(),
feature.properties() != null ? feature.properties().entrySet().size() : "<null>",
feature.geometry() != null ? feature.geometry().getClass().getSimpleName() : "<null>"
);
if (feature.getProperties() != null) {
for (Map.Entry<String, JsonElement> entry : feature.getProperties().entrySet()) {
if (feature.properties() != null) {
for (Map.Entry<String, JsonElement> entry : feature.properties().entrySet()) {
Timber.i("Prop %s - %s", entry.getKey(), entry.getValue());
}
}
@@ -114,7 +115,7 @@ public class QueryRenderedFeaturesPropertiesActivity extends AppCompatActivity {
if (customMarker.features.size() > 0) {
view.addView(row(String.format("Found %s features", customMarker.features.size())));
Feature feature = customMarker.features.get(0);
for (Map.Entry<String, JsonElement> prop : feature.getProperties().entrySet()) {
for (Map.Entry<String, JsonElement> prop : feature.properties().entrySet()) {
view.addView(row(String.format("%s: %s", prop.getKey(), prop.getValue())));
}
} else {

9
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/feature/QuerySourceFeaturesActivity.java
View File

@@ -5,15 +5,16 @@ import android.support.v7.app.AppCompatActivity;
import android.widget.Toast;
import com.google.gson.JsonObject;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.FeatureCollection;
import com.mapbox.geojson.Point;
import com.mapbox.mapboxsdk.maps.MapView;
import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.style.layers.CircleLayer;
import com.mapbox.mapboxsdk.style.layers.Filter;
import com.mapbox.mapboxsdk.style.sources.GeoJsonSource;
import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.FeatureCollection;
import com.mapbox.services.commons.geojson.Point;
import java.util.List;
@@ -42,7 +43,7 @@ public class QuerySourceFeaturesActivity extends AppCompatActivity {
properties.addProperty("key1", "value1");
final GeoJsonSource source = new GeoJsonSource("test-source",
FeatureCollection.fromFeatures(new Feature[] {
Feature.fromGeometry(Point.fromCoordinates(new double[] {0, 0}), properties)
Feature.fromGeometry(Point.fromLngLat(0, 0), properties)
}));
mapboxMap.addSource(source);

18
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/CustomSpriteActivity.java
View File

@@ -7,6 +7,9 @@ import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.FeatureCollection;
import com.mapbox.geojson.Point;
import com.mapbox.mapboxsdk.camera.CameraUpdateFactory;
import com.mapbox.mapboxsdk.geometry.LatLng;
import com.mapbox.mapboxsdk.maps.MapView;
@@ -15,10 +18,7 @@ import com.mapbox.mapboxsdk.style.layers.Layer;
import com.mapbox.mapboxsdk.style.layers.SymbolLayer;
import com.mapbox.mapboxsdk.style.sources.GeoJsonSource;
import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.FeatureCollection;
import com.mapbox.services.commons.geojson.Point;
import com.mapbox.services.commons.models.Position;
import timber.log.Timber;
@@ -58,7 +58,7 @@ public class CustomSpriteActivity extends AppCompatActivity {
mapboxMap.addImage(CUSTOM_ICON, BitmapFactory.decodeResource(getResources(), R.drawable.ic_car_top));
// Add a source with a geojson point
point = Point.fromCoordinates(Position.fromCoordinates(13.400972d, 52.519003d));
point = Point.fromLngLat(13.400972d, 52.519003d);
source = new GeoJsonSource(
"point",
FeatureCollection.fromFeatures(new Feature[] {Feature.fromGeometry(point)})
@@ -78,15 +78,13 @@ public class CustomSpriteActivity extends AppCompatActivity {
fab.setImageResource(R.drawable.ic_directions_car_black);
} else {
// Update point
point = Point.fromCoordinates(
Position.fromCoordinates(point.getCoordinates().getLongitude() + 0.001,
point.getCoordinates().getLatitude() + 0.001)
);
point = Point.fromLngLat(point.longitude() + 0.001,
point.latitude() + 0.001);
source.setGeoJson(FeatureCollection.fromFeatures(new Feature[] {Feature.fromGeometry(point)}));
// Move the camera as well
mapboxMap.moveCamera(CameraUpdateFactory.newLatLng(new LatLng(
point.getCoordinates().getLatitude(), point.getCoordinates().getLongitude())));
point.latitude(), point.longitude())));
}
}
});

4
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/FillExtrusionActivity.java
View File

@@ -12,7 +12,7 @@ import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.style.layers.FillExtrusionLayer;
import com.mapbox.mapboxsdk.style.sources.GeoJsonSource;
import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.services.commons.geojson.Polygon;
import com.mapbox.geojson.Polygon;
import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.fillExtrusionColor;
import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.fillExtrusionHeight;
@@ -35,7 +35,7 @@ public class FillExtrusionActivity extends AppCompatActivity {
mapView.onCreate(savedInstanceState);
mapView.getMapAsync(map -> {
mapboxMap = map;
Polygon domTower = Polygon.fromCoordinates(new double[][][] {
Polygon domTower = Polygon.fromLngLats(new double[][][] {
new double[][] {
new double[] {
5.12112557888031,

21
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/GridSourceActivity.java
View File

@@ -5,6 +5,10 @@ import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v7.app.AppCompatActivity;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.FeatureCollection;
import com.mapbox.geojson.MultiLineString;
import com.mapbox.geojson.Point;
import com.mapbox.mapboxsdk.geometry.LatLngBounds;
import com.mapbox.mapboxsdk.maps.MapView;
import com.mapbox.mapboxsdk.maps.MapboxMap;
@@ -13,10 +17,7 @@ import com.mapbox.mapboxsdk.style.layers.LineLayer;
import com.mapbox.mapboxsdk.style.sources.CustomGeometrySource;
import com.mapbox.mapboxsdk.style.sources.GeometryTileProvider;
import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.FeatureCollection;
import com.mapbox.services.commons.geojson.MultiLineString;
import com.mapbox.services.commons.models.Position;
import java.util.ArrayList;
import java.util.Arrays;
@@ -68,18 +69,18 @@ public class GridSourceActivity extends AppCompatActivity implements OnMapReadyC
List gridLines = new ArrayList();
for (double y = Math.ceil(bounds.getLatNorth() / gridSpacing) * gridSpacing;
y >= Math.floor(bounds.getLatSouth() / gridSpacing) * gridSpacing; y -= gridSpacing) {
gridLines.add(Arrays.asList(Position.fromCoordinates(bounds.getLonWest(), y),
Position.fromCoordinates(bounds.getLonEast(), y)));
gridLines.add(Arrays.asList(Point.fromLngLat(bounds.getLonWest(), y),
Point.fromLngLat(bounds.getLonEast(), y)));
}
features.add(Feature.fromGeometry(MultiLineString.fromCoordinates(gridLines)));
features.add(Feature.fromGeometry(MultiLineString.fromLngLats(gridLines)));
gridLines = new ArrayList();
for (double x = Math.floor(bounds.getLonWest() / gridSpacing) * gridSpacing;
x <= Math.ceil(bounds.getLonEast() / gridSpacing) * gridSpacing; x += gridSpacing) {
gridLines.add(Arrays.asList(Position.fromCoordinates(x, bounds.getLatSouth()),
Position.fromCoordinates(x, bounds.getLatNorth())));
gridLines.add(Arrays.asList(Point.fromLngLat(x, bounds.getLatSouth()),
Point.fromLngLat(x, bounds.getLatNorth())));
}
features.add(Feature.fromGeometry(MultiLineString.fromCoordinates(gridLines)));
features.add(Feature.fromGeometry(MultiLineString.fromLngLats(gridLines)));
return FeatureCollection.fromFeatures(features);
}

9
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/RuntimeStyleActivity.java
View File

@@ -8,6 +8,8 @@ import android.view.Menu;
import android.view.MenuItem;
import android.widget.Toast;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.FeatureCollection;
import com.mapbox.mapboxsdk.camera.CameraUpdateFactory;
import com.mapbox.mapboxsdk.geometry.LatLng;
import com.mapbox.mapboxsdk.maps.MapView;
@@ -28,8 +30,7 @@ import com.mapbox.mapboxsdk.style.sources.TileSet;
import com.mapbox.mapboxsdk.style.sources.VectorSource;
import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.mapboxsdk.testapp.utils.ResourceUtils;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.FeatureCollection;
import java.io.IOException;
import java.util.ArrayList;
@@ -364,7 +365,7 @@ public class RuntimeStyleActivity extends AppCompatActivity {
Timber.d("Updating parks source");
// change the source
int park = counter < parks.getFeatures().size() - 1 ? counter : 0;
int park = counter < parks.features().size() - 1 ? counter : 0;
GeoJsonSource source = mapboxMap.getSourceAs("dynamic-park-source");
@@ -375,7 +376,7 @@ public class RuntimeStyleActivity extends AppCompatActivity {
}
List<Feature> features = new ArrayList<>();
features.add(parks.getFeatures().get(park));
features.add(parks.features().get(park));
source.setGeoJson(FeatureCollection.fromFeatures(features));
// Re-post

20
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/SymbolGeneratorActivity.java
View File

@@ -15,7 +15,8 @@ import android.view.View;
import android.widget.TextView;
import android.widget.Toast;
import com.google.gson.GsonBuilder;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.FeatureCollection;
import com.mapbox.mapboxsdk.maps.MapView;
import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
@@ -25,12 +26,7 @@ import com.mapbox.mapboxsdk.style.sources.GeoJsonSource;
import com.mapbox.mapboxsdk.style.sources.Source;
import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.mapboxsdk.testapp.utils.ResourceUtils;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.FeatureCollection;
import com.mapbox.services.commons.geojson.Geometry;
import com.mapbox.services.commons.geojson.custom.GeometryDeserializer;
import com.mapbox.services.commons.geojson.custom.PositionDeserializer;
import com.mapbox.services.commons.models.Position;
import java.io.IOException;
import java.util.HashMap;
@@ -211,14 +207,8 @@ public class SymbolGeneratorActivity extends AppCompatActivity implements OnMapR
try {
// read local geojson from raw folder
String tinyCountriesJson = ResourceUtils.readRawResource(activity, R.raw.tiny_countries);
return FeatureCollection.fromJson(tinyCountriesJson);
// convert geojson to a model
FeatureCollection featureCollection = new GsonBuilder()
.registerTypeAdapter(Geometry.class, new GeometryDeserializer())
.registerTypeAdapter(Position.class, new PositionDeserializer())
.create().fromJson(tinyCountriesJson, FeatureCollection.class);
return featureCollection;
} catch (IOException exception) {
return null;
}
@@ -288,7 +278,7 @@ public class SymbolGeneratorActivity extends AppCompatActivity implements OnMapR
FeatureCollection featureCollection = params[0];
HashMap<String, Bitmap> imagesMap = new HashMap<>();
for (Feature feature : featureCollection.getFeatures()) {
for (Feature feature : featureCollection.features()) {
String countryName = feature.getStringProperty(FEATURE_ID);
TextView textView = new TextView(context);
textView.setBackgroundColor(context.getResources().getColor(R.color.blueAccent));

11
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/SymbolLayerActivity.java
View File

@@ -11,6 +11,9 @@ import android.view.MenuItem;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.FeatureCollection;
import com.mapbox.geojson.Point;
import com.mapbox.mapboxsdk.camera.CameraUpdateFactory;
import com.mapbox.mapboxsdk.geometry.LatLng;
import com.mapbox.mapboxsdk.maps.MapView;
@@ -18,9 +21,7 @@ import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.style.layers.SymbolLayer;
import com.mapbox.mapboxsdk.style.sources.GeoJsonSource;
import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.FeatureCollection;
import com.mapbox.services.commons.geojson.Point;
import java.util.Arrays;
import java.util.List;
@@ -62,8 +63,8 @@ public class SymbolLayerActivity extends AppCompatActivity implements MapboxMap.
// Add a source
FeatureCollection markers = FeatureCollection.fromFeatures(new Feature[] {
Feature.fromGeometry(Point.fromCoordinates(new double[] {4.91638, 52.35673}), featureProperties("Marker 1")),
Feature.fromGeometry(Point.fromCoordinates(new double[] {4.91638, 52.34673}), featureProperties("Marker 2"))
Feature.fromGeometry(Point.fromLngLat(4.91638, 52.35673), featureProperties("Marker 1")),
Feature.fromGeometry(Point.fromLngLat(4.91638, 52.34673), featureProperties("Marker 2"))
});
mapboxMap.addSource(new GeoJsonSource(MARKER_SOURCE, markers));

18
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/style/ZoomFunctionSymbolLayerActivity.java
View File

@@ -7,16 +7,16 @@ import android.view.Menu;
import android.view.MenuItem;
import com.google.gson.JsonObject;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.FeatureCollection;
import com.mapbox.geojson.Point;
import com.mapbox.mapboxsdk.maps.MapView;
import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.style.layers.Property;
import com.mapbox.mapboxsdk.style.layers.SymbolLayer;
import com.mapbox.mapboxsdk.style.sources.GeoJsonSource;
import com.mapbox.mapboxsdk.testapp.R;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.FeatureCollection;
import com.mapbox.services.commons.geojson.Point;
import com.mapbox.services.commons.models.Position;
import java.util.List;
@@ -87,15 +87,13 @@ public class ZoomFunctionSymbolLayerActivity extends AppCompatActivity {
}
private FeatureCollection createFeatureCollection() {
Position position = isInitialPosition
? Position.fromCoordinates(-74.01618140, 40.701745)
: Position.fromCoordinates(-73.988097, 40.749864);
Point point = isInitialPosition
? Point.fromLngLat(-74.01618140, 40.701745)
: Point.fromLngLat(-73.988097, 40.749864);
Point point = Point.fromCoordinates(position);
Feature feature = Feature.fromGeometry(point);
JsonObject properties = new JsonObject();
properties.addProperty(KEY_PROPERTY_SELECTED, isSelected);
feature.setProperties(properties);
Feature feature = Feature.fromGeometry(point, properties);
return FeatureCollection.fromFeatures(new Feature[] {feature});
}

16
platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/utils/GeoParseUtil.java
View File

@@ -2,11 +2,11 @@ package com.mapbox.mapboxsdk.testapp.utils;
import android.content.Context;
import android.text.TextUtils;
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.FeatureCollection;
import com.mapbox.geojson.Point;
import com.mapbox.mapboxsdk.geometry.LatLng;
import com.mapbox.services.commons.geojson.Feature;
import com.mapbox.services.commons.geojson.FeatureCollection;
import com.mapbox.services.commons.geojson.Point;
import com.mapbox.services.commons.models.Position;
import java.io.BufferedReader;
import java.io.IOException;
@@ -31,10 +31,10 @@ public class GeoParseUtil {
public static List<LatLng> parseGeoJsonCoordinates(String geojsonStr) {
List<LatLng> latLngs = new ArrayList<>();
FeatureCollection featureCollection = FeatureCollection.fromJson(geojsonStr);
for (Feature feature : featureCollection.getFeatures()) {
if (feature.getGeometry() instanceof Point) {
Position point = ((Point) feature.getGeometry()).getCoordinates();
latLngs.add(new LatLng(point.getLatitude(), point.getLongitude()));
for (Feature feature : featureCollection.features()) {
if (feature.geometry() instanceof Point) {
Point point = (Point) feature.geometry();
latLngs.add(new LatLng(point.latitude(), point.longitude()));
}
}
return latLngs;

2
platform/android/config.cmake
View File

@@ -248,8 +248,6 @@ add_library(mbgl-android STATIC
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/lat_lng.cpp

12
platform/android/gradle/dependencies.gradle
View File

@@ -8,7 +8,8 @@ ext {
]
versions = [
mapboxServices: '2.2.9',
mapboxServices: '3.0.0-beta.2',
mapboxTelemetry: '2.2.9',
supportLib : '25.4.0',
espresso : '3.0.1',
testRunner : '1.0.1',
@@ -22,9 +23,12 @@ ext {
]
dependenciesList = [
mapboxJavaServices : "com.mapbox.mapboxsdk:mapbox-java-services:${versions.mapboxServices}@jar",
mapboxJavaGeoJSON : "com.mapbox.mapboxsdk:mapbox-java-geojson:${versions.mapboxServices}@jar",
mapboxAndroidTelemetry: "com.mapbox.mapboxsdk:mapbox-android-telemetry:${versions.mapboxServices}@aar",
mapboxJavaServices : "com.mapbox.mapboxsdk:mapbox-sdk-services:${versions.mapboxServices}@jar",
mapboxJavaGeoJSON : "com.mapbox.mapboxsdk:mapbox-sdk-geojson:${versions.mapboxServices}@jar",
mapboxAndroidTelemetry: "com.mapbox.mapboxsdk:mapbox-android-telemetry:${versions.mapboxTelemetry}@aar",
// for testApp
mapboxJavaTurf : "com.mapbox.mapboxsdk:mapbox-sdk-turf:${versions.mapboxServices}@jar",
junit : "junit:junit:${versions.junit}",
mockito : "org.mockito:mockito-core:${versions.mockito}",

130
platform/android/src/geojson/conversion/geometry.hpp
View File

@@ -21,88 +21,91 @@ public:
jni::JNIEnv& env;
/**
* Point (double[])
* static Point fromLngLat(double longitude,double latitude)
*/
jni::jobject* operator()(const mapbox::geometry::point<T> &geometry) const {
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/services/commons/geojson/Point")).release();
static jni::jmethodID* fromCoordinates = &jni::GetStaticMethodID(env, *javaClass, "fromCoordinates", "([D)Lcom/mapbox/services/commons/geojson/Point;");
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/geojson/Point")).release();
static jni::jmethodID* fromLngLat = &jni::GetStaticMethodID(env, *javaClass, "fromLngLat", "(DD)Lcom/mapbox/geojson/Point;");
// Create Point
jni::LocalObject<jni::jarray<jni::jdouble>> position = jni::NewLocalObject(env, toGeoJsonPosition(env, geometry.x, geometry.y));
return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *fromCoordinates, position.get()));
return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *fromLngLat, geometry.x, geometry.y));
}
/**
* LineString (double[][])
* static LineString fromLngLats(List<Point> points)
*/
jni::jobject* operator()(const mapbox::geometry::line_string<T> &geometry) const {
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/services/commons/geojson/LineString")).release();
static jni::jmethodID* fromCoordinates = &jni::GetStaticMethodID(env, *javaClass, "fromCoordinates", "([[D)Lcom/mapbox/services/commons/geojson/LineString;");
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/geojson/LineString")).release();
static jni::jmethodID* fromLngLats = &jni::GetStaticMethodID(env, *javaClass, "fromLngLats", "(Ljava/util/List;)Lcom/mapbox/geojson/LineString;");
// Create
jni::LocalObject<jni::jarray<jni::jobject>> coordinates = jni::NewLocalObject(env, toGeoJsonCoordinates(env, geometry));
return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *fromCoordinates, coordinates.get()));
jni::LocalObject<jni::jobject> listOfPoints = jni::NewLocalObject(env, toGeoJsonListOfPoints(env, geometry));
return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *fromLngLats, listOfPoints.get()));
}
/**
* MultiPoint (double[][])
* static MultiPoint fromLngLats(List<Point> points)
*/
jni::jobject* operator()(const mapbox::geometry::multi_point<T> &geometry) const {
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/services/commons/geojson/MultiPoint")).release();
static jni::jmethodID* fromCoordinates = &jni::GetStaticMethodID(env, *javaClass, "fromCoordinates", "([[D)Lcom/mapbox/services/commons/geojson/MultiPoint;");
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/geojson/MultiPoint")).release();
static jni::jmethodID* fromLngLats = &jni::GetStaticMethodID(env, *javaClass, "fromLngLats", "(Ljava/util/List;)Lcom/mapbox/geojson/MultiPoint;");
// Create
jni::LocalObject<jni::jarray<jni::jobject>> coordinates = jni::NewLocalObject(env, toGeoJsonCoordinates(env, geometry));
return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *fromCoordinates, coordinates.get()));
jni::LocalObject<jni::jobject> coordinates = jni::NewLocalObject(env, toGeoJsonListOfPoints(env, geometry));
return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *fromLngLats, coordinates.get()));
}
/**
* Polygon (double[][][])
* static Polygon fromLngLats(List<List<Point>> coordinates)
*/
jni::jobject* operator()(const mapbox::geometry::polygon<T> &geometry) const {
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/services/commons/geojson/Polygon")).release();
static jni::jmethodID* fromCoordinates = &jni::GetStaticMethodID(env, *javaClass, "fromCoordinates", "([[[D)Lcom/mapbox/services/commons/geojson/Polygon;");
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/geojson/Polygon")).release();
static jni::jmethodID* fromLngLats = &jni::GetStaticMethodID(env, *javaClass, "fromLngLats", "(Ljava/util/List;)Lcom/mapbox/geojson/Polygon;");
// Create
jni::LocalObject<jni::jarray<jni::jobject>> shape = jni::NewLocalObject(env, toShape<>(env, geometry));
return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *fromCoordinates, shape.get()));
jni::LocalObject<jni::jobject> shape = jni::NewLocalObject(env, toShape<>(env, geometry));
return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *fromLngLats, shape.get()));
}
/**
* MultiLineString (double[][][])
* static MultiLineString fromLngLats(List<List<Point>> points)
*/
jni::jobject* operator()(const mapbox::geometry::multi_line_string<T> &geometry) const {
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/services/commons/geojson/MultiLineString")).release();
static jni::jmethodID* fromCoordinates = &jni::GetStaticMethodID(env, *javaClass, "fromCoordinates", "([[[D)Lcom/mapbox/services/commons/geojson/MultiLineString;");
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/geojson/MultiLineString")).release();
static jni::jmethodID* fromLngLats = &jni::GetStaticMethodID(env, *javaClass, "fromLngLats", "(Ljava/util/List;)Lcom/mapbox/geojson/MultiLineString;");
// Create
jni::LocalObject<jni::jarray<jni::jobject>> shape = jni::NewLocalObject(env, toShape<>(env, geometry));
return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *fromCoordinates, shape.get()));
jni::LocalObject<jni::jobject> shape = jni::NewLocalObject(env, toShape<>(env, geometry));
return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *fromLngLats, shape.get()));
}
/**
* MultiPolygon (double[][][][]) -> [[[D + Object array == [[[[D
*
* static MultiPolygon fromLngLats(List<List<List<Point>>> points)
*/
jni::jobject* operator()(const mapbox::geometry::multi_polygon<T> &geometry) const {
static jni::jclass* listClass = jni::NewGlobalRef(env, &jni::FindClass(env, "[[[D")).release();
jni::LocalObject<jni::jarray<jni::jobject>> jarray = jni::NewLocalObject(env, &jni::NewObjectArray(env, geometry.size(), *listClass));
// ArrayList
static jni::jclass* arrayListClass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/util/ArrayList")).release();
static jni::jmethodID* constructor = &jni::GetMethodID(env, *arrayListClass, "<init>", "(I)V");
static jni::jmethodID* add = &jni::GetMethodID(env, *arrayListClass, "add", "(ILjava/lang/Object;)V");
jni::jobject* arrayList = &jni::NewObject(env, *arrayListClass, *constructor, geometry.size());
for(size_t i = 0; i < geometry.size(); i = i + 1) {
jni::LocalObject<jni::jarray<jni::jobject>> shape = jni::NewLocalObject(env, toShape<>(env, geometry.at(i)));
jni::SetObjectArrayElement(env, *jarray, i, shape.get());
jni::LocalObject<jni::jobject> shape = jni::NewLocalObject(env, toShape<>(env, geometry.at(i)));
jni::CallMethod<void>(env, arrayList, *add, i, shape.get());
}
// Create the MultiPolygon
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/services/commons/geojson/MultiPolygon")).release();
static jni::jmethodID* fromGeometries = &jni::GetStaticMethodID(env, *javaClass, "fromCoordinates", "([[[[D)Lcom/mapbox/services/commons/geojson/MultiPolygon;");
return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *fromGeometries, jarray.get()));
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/geojson/MultiPolygon")).release();
static jni::jmethodID* fromGeometries = &jni::GetStaticMethodID(env, *javaClass, "fromLngLats", "(Ljava/util/List;)Lcom/mapbox/geojson/MultiPolygon;");
return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *fromGeometries, arrayList));
}
/**
* GeometryCollection
*/
jni::jobject* operator()(const mapbox::geometry::geometry_collection<T> &collection) const {
static jni::jclass* geometryClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/services/commons/geojson/Geometry")).release();
static jni::jclass* geometryClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/geojson/Geometry")).release();
jni::LocalObject<jni::jarray<jni::jobject>> jarray = jni::NewLocalObject(env, &jni::NewObjectArray(env, collection.size(), *geometryClass));
for(size_t i = 0; i < collection.size(); i = i + 1) {
@@ -112,8 +115,8 @@ public:
}
// Turn into array list and create the GeometryCollection
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/services/commons/geojson/GeometryCollection")).release();
static jni::jmethodID* fromGeometries = &jni::GetStaticMethodID(env, *javaClass, "fromGeometries", "(Ljava/util/List;)Lcom/mapbox/services/commons/geojson/GeometryCollection;");
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/geojson/GeometryCollection")).release();
static jni::jmethodID* fromGeometries = &jni::GetStaticMethodID(env, *javaClass, "fromGeometries", "(Ljava/util/List;)Lcom/mapbox/geojson/GeometryCollection;");
jni::LocalObject<jni::jobject> list = jni::NewLocalObject(env, toArrayList<>(env, *jarray));
return reinterpret_cast<jni::jobject*>(jni::CallStaticMethod<jni::jobject*>(env, *javaClass, *fromGeometries, list.get()));
@@ -122,47 +125,50 @@ public:
private:
/**
* x, y -> jarray<jdouble> ([x,y])
*/
static jni::jarray<jni::jdouble>* toGeoJsonPosition(JNIEnv& env, double x, double y) {
jni::jarray<jni::jdouble>& jarray = jni::NewArray<jni::jdouble>(env, 2);
jni::jdouble array[] = {x, y};
jni::SetArrayRegion(env, jarray, 0, 2, array);
return &jarray;
}
* vector<point<T>> -> List<Point>
*/
static jni::jobject* toGeoJsonListOfPoints(JNIEnv& env, std::vector<mapbox::geometry::point<T>> points) {
/**
* vector<point<T>> -> jarray<jobject> (double[][]) -> [D + Object array == [[D
*/
static jni::jarray<jni::jobject>* toGeoJsonCoordinates(JNIEnv& env, std::vector<mapbox::geometry::point<T>> points) {
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "[D")).release();
jni::jarray<jni::jobject>& jarray = jni::NewObjectArray(env, points.size(), *javaClass);
// ArrayList
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/util/ArrayList")).release();
static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "(I)V");
static jni::jmethodID* add = &jni::GetMethodID(env, *javaClass, "add", "(ILjava/lang/Object;)V");
jni::jobject* arrayList = &jni::NewObject(env, *javaClass, *constructor, points.size());
// Point
static jni::jclass* pointJavaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "com/mapbox/geojson/Point")).release();
static jni::jmethodID* fromLngLat = &jni::GetStaticMethodID(env, *pointJavaClass, "fromLngLat", "(DD)Lcom/mapbox/geojson/Point;");
for(size_t i = 0; i < points.size(); i = i + 1) {
mapbox::geometry::point<T> point = points.at(i);
jni::LocalObject<jni::jarray<jni::jdouble>> position = jni::NewLocalObject(env, toGeoJsonPosition(env, point.x, point.y));
jni::SetObjectArrayElement(env, jarray, i, position.get());
jni::LocalObject<jni::jobject> pointObject =
jni::NewLocalObject(env, jni::CallStaticMethod<jni::jobject*>(env, *pointJavaClass, *fromLngLat, point.x, point.y));
jni::CallMethod<void>(env, arrayList, *add, i, pointObject.get());
}
return &jarray;
return arrayList;
}
/**
* polygon<T>
* multi_line_string<T>
* -> jarray<jobject> (double[][][]) -> [[D + Object array == [[[D
* geometry -> List<List<Point>>
*/
template <class SHAPE>
static jni::jarray<jni::jobject>* toShape(JNIEnv& env, SHAPE value) {
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "[[D")).release();
jni::jarray<jni::jobject>& jarray = jni::NewObjectArray(env, value.size(), *javaClass);
static jni::jobject* toShape(JNIEnv& env, SHAPE value) {
// ArrayList
static jni::jclass* javaClass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/util/ArrayList")).release();
static jni::jmethodID* constructor = &jni::GetMethodID(env, *javaClass, "<init>", "(I)V");
static jni::jmethodID* add = &jni::GetMethodID(env, *javaClass, "add", "(ILjava/lang/Object;)V");
jni::jobject* arrayList = &jni::NewObject(env, *javaClass, *constructor, value.size());
for(size_t i = 0; i < value.size(); i = i + 1) {
jni::LocalObject<jni::jarray<jni::jobject>> coordinates = jni::NewLocalObject(env, toGeoJsonCoordinates(env, value.at(i)));
jni::SetObjectArrayElement(env, jarray, i, coordinates.get());
jni::LocalObject<jni::jobject> listOfPoints = jni::NewLocalObject(env, toGeoJsonListOfPoints(env, value.at(i)));
jni::CallMethod<void>(env, arrayList, *add, i, listOfPoints.get());
}
return &jarray;
return arrayList;
}
};

18
platform/android/src/geojson/feature.cpp
View File

@@ -8,11 +8,11 @@ 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);
auto jGeometry = geometry(env, jFeature);
auto jProperties = Feature::properties(env, jFeature);
std::experimental::optional<mapbox::geometry::identifier> id;
auto jId = Feature::getId(env, jFeature);
auto jId = Feature::id(env, jFeature);
if (jId) {
id = { jni::Make<std::string>(env, jId) };
}
@@ -31,18 +31,18 @@ mbgl::Feature Feature::convert(jni::JNIEnv& env, jni::Object<Feature> jFeature)
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");
jni::Object<Geometry> Feature::geometry(jni::JNIEnv& env, jni::Object<Feature> jFeature) {
static auto method = Feature::javaClass.GetMethod<jni::Object<Geometry> ()>(env, "geometry");
return jFeature.Call(env, method);
}
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");
jni::Object<gson::JsonObject> Feature::properties(jni::JNIEnv& env, jni::Object<Feature> jFeature) {
static auto method = Feature::javaClass.GetMethod<jni::Object<gson::JsonObject> ()>(env, "properties");
return jFeature.Call(env, method);
}
jni::String Feature::getId(jni::JNIEnv& env, jni::Object<Feature> jFeature) {
static auto method = Feature::javaClass.GetMethod<jni::String ()>(env, "getId");
jni::String Feature::id(jni::JNIEnv& env, jni::Object<Feature> jFeature) {
static auto method = Feature::javaClass.GetMethod<jni::String ()>(env, "id");
return jFeature.Call(env, method);
}

8
platform/android/src/geojson/feature.hpp
View File

@@ -16,17 +16,17 @@ namespace geojson {
class Feature : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/services/commons/geojson/Feature"; };
static constexpr auto Name() { return "com/mapbox/geojson/Feature"; };
static jni::Object<Feature> fromGeometry(jni::JNIEnv&, jni::Object<Geometry>, jni::Object<gson::JsonObject>, jni::String);
static mbgl::Feature convert(jni::JNIEnv&, jni::Object<Feature>);
static jni::Object<Geometry> getGeometry(jni::JNIEnv&, jni::Object<Feature>);
static jni::Object<Geometry> geometry(jni::JNIEnv&, jni::Object<Feature>);
static jni::String getId(jni::JNIEnv&, jni::Object<Feature>);
static jni::String id(jni::JNIEnv&, jni::Object<Feature>);
static jni::Object<gson::JsonObject> getProperties(jni::JNIEnv&, jni::Object<Feature>);
static jni::Object<gson::JsonObject> properties(jni::JNIEnv&, jni::Object<Feature>);
static jni::Class<Feature> javaClass;

6
platform/android/src/geojson/feature_collection.cpp
View File

@@ -7,7 +7,7 @@ namespace android {
namespace geojson {
mbgl::FeatureCollection FeatureCollection::convert(jni::JNIEnv& env, jni::Object<FeatureCollection> jCollection) {
auto jFeatureList = FeatureCollection::getFeatures(env, jCollection);
auto jFeatureList = FeatureCollection::features(env, jCollection);
auto jFeatures = java::util::List::toArray<Feature>(env, jFeatureList);
auto size = size_t(jFeatures.Length(env));
@@ -23,8 +23,8 @@ mbgl::FeatureCollection FeatureCollection::convert(jni::JNIEnv& env, jni::Object
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");
jni::Object<java::util::List> FeatureCollection::features(jni::JNIEnv& env, jni::Object<FeatureCollection> jCollection) {
static auto method = FeatureCollection::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "features");
return jCollection.Call(env, method);
}

4
platform/android/src/geojson/feature_collection.hpp
View File

@@ -13,11 +13,11 @@ namespace geojson {
class FeatureCollection : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/services/commons/geojson/FeatureCollection"; };
static constexpr auto Name() { return "com/mapbox/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::Object<java::util::List> features(jni::JNIEnv&, jni::Object<FeatureCollection>);
static jni::Class<FeatureCollection> javaClass;

2
platform/android/src/geojson/geometry.cpp
View File

@@ -33,7 +33,7 @@ mapbox::geojson::geometry Geometry::convert(jni::JNIEnv &env, jni::Object<Geomet
}
std::string Geometry::getType(jni::JNIEnv &env, jni::Object<Geometry> jGeometry) {
static auto method = Geometry::javaClass.GetMethod<jni::String ()>(env, "getType");
static auto method = Geometry::javaClass.GetMethod<jni::String ()>(env, "type");
auto jType = jGeometry.Call(env, method);
auto type = jni::Make<std::string>(env, jType);
jni::DeleteLocalRef(env, jType);

2
platform/android/src/geojson/geometry.hpp
View File

@@ -11,7 +11,7 @@ namespace geojson {
class Geometry : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/services/commons/geojson/Geometry"; };
static constexpr auto Name() { return "com/mapbox/geojson/Geometry"; };
static mapbox::geojson::geometry convert(jni::JNIEnv&, jni::Object<Geometry>);

28
platform/android/src/geojson/line_string.cpp
View File

@@ -1,6 +1,6 @@
#include "line_string.hpp"
#include "position.hpp"
#include "point.hpp"
namespace mbgl {
namespace android {
@@ -10,35 +10,35 @@ mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, jni::Object<L
mapbox::geojson::line_string lineString;
if (jLineString) {
auto jPositionList = LineString::getCoordinates(env, jLineString);
lineString = LineString::convert(env, jPositionList);
jni::DeleteLocalRef(env, jPositionList);
auto jPointList = LineString::coordinates(env, jLineString);
lineString = LineString::convert(env, jPointList);
jni::DeleteLocalRef(env, jPointList);
}
return lineString;
}
mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, jni::Object<java::util::List/*<Position>*/> jPositionList) {
mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, jni::Object<java::util::List/*<Point>*/> jPointList) {
mapbox::geojson::line_string lineString;
if (jPositionList) {
auto jPositionArray = java::util::List::toArray<Position>(env, jPositionList);
if (jPointList) {
auto jPointArray = java::util::List::toArray<Point>(env, jPointList);
auto size = jPositionArray.Length(env);
auto size = jPointArray.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);
auto jPoint = jPointArray.Get(env, i);
lineString.push_back(Point::convert(env, jPoint));
jni::DeleteLocalRef(env, jPoint);
}
jni::DeleteLocalRef(env, jPositionArray);
jni::DeleteLocalRef(env, jPointArray);
}
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");
jni::Object<java::util::List> LineString::coordinates(jni::JNIEnv &env, jni::Object<LineString> jLineString) {
static auto method = LineString::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
return jLineString.Call(env, method);
}

6
platform/android/src/geojson/line_string.hpp
View File

@@ -14,15 +14,15 @@ namespace geojson {
class LineString : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/services/commons/geojson/LineString"; };
static constexpr auto Name() { return "com/mapbox/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 mapbox::geojson::line_string convert(jni::JNIEnv&, jni::Object<java::util::List/*<Point>*/>);
static jni::Object<java::util::List> getCoordinates(jni::JNIEnv&, jni::Object<LineString>);
static jni::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<LineString>);
static jni::Class<LineString> javaClass;

22
platform/android/src/geojson/multi_line_string.cpp
View File

@@ -10,27 +10,27 @@ mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv &env, jn
mapbox::geojson::multi_line_string multiLineString;
if (jMultiLineString) {
auto jPositionListsList = MultiLineString::getCoordinates(env, jMultiLineString);
multiLineString = MultiLineString::convert(env, jPositionListsList);
jni::DeleteLocalRef(env, jPositionListsList);
auto jPointListsList = MultiLineString::coordinates(env, jMultiLineString);
multiLineString = MultiLineString::convert(env, jPointListsList);
jni::DeleteLocalRef(env, jPointListsList);
}
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::convert(jni::JNIEnv &env, jni::Object<java::util::List/*<java::util::List<Point>>*/> jPointListsList) {
mapbox::geojson::multi_line_string multiLineString;
if (jPositionListsList) {
auto jPositionListsArray = java::util::List::toArray<java::util::List>(env, jPositionListsList);
if (jPointListsList) {
auto jPositionListsArray = java::util::List::toArray<java::util::List>(env, jPointListsList);
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);
auto jPointsList = jPositionListsArray.Get(env, i);
multiLineString.push_back(LineString::convert(env, jPointsList));
jni::DeleteLocalRef(env, jPointsList);
}
jni::DeleteLocalRef(env, jPositionListsArray);
@@ -39,8 +39,8 @@ mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv &env, jn
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");
jni::Object<java::util::List> MultiLineString::coordinates(jni::JNIEnv &env, jni::Object<MultiLineString> jLineString) {
static auto method = MultiLineString::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
return jLineString.Call(env, method);
}

6
platform/android/src/geojson/multi_line_string.hpp
View File

@@ -13,15 +13,15 @@ namespace geojson {
class MultiLineString : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/services/commons/geojson/MultiLineString"; };
static constexpr auto Name() { return "com/mapbox/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 mapbox::geojson::multi_line_string convert(jni::JNIEnv&, jni::Object<java::util::List/*<java::util::List<Point>>*/>);
static jni::Object<java::util::List> getCoordinates(jni::JNIEnv&, jni::Object<MultiLineString>);
static jni::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<MultiLineString>);
static jni::Class<MultiLineString> javaClass;

10
platform/android/src/geojson/multi_point.cpp
View File

@@ -12,16 +12,16 @@ mapbox::geojson::multi_point MultiPoint::convert(jni::JNIEnv &env, jni::Object<M
mapbox::geojson::multi_point multiPoint;
if (jMultiPoint) {
auto jPositionListsList = MultiPoint::getCoordinates(env, jMultiPoint);
multiPoint = convertExplicit<mapbox::geojson::multi_point>(LineString::convert(env, jPositionListsList));
jni::DeleteLocalRef(env, jPositionListsList);
auto jPointListsList = MultiPoint::coordinates(env, jMultiPoint);
multiPoint = convertExplicit<mapbox::geojson::multi_point>(LineString::convert(env, jPointListsList));
jni::DeleteLocalRef(env, jPointListsList);
}
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");
jni::Object<java::util::List> MultiPoint::coordinates(jni::JNIEnv &env, jni::Object<MultiPoint> jMultiPoint) {
static auto method = MultiPoint::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
return jMultiPoint.Call(env, method);
}

4
platform/android/src/geojson/multi_point.hpp
View File

@@ -13,13 +13,13 @@ namespace geojson {
class MultiPoint : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/services/commons/geojson/MultiPoint"; };
static constexpr auto Name() { return "com/mapbox/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::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<MultiPoint>);
static jni::Class<MultiPoint> javaClass;

16
platform/android/src/geojson/multi_polygon.cpp
View File

@@ -10,27 +10,27 @@ mapbox::geojson::multi_polygon MultiPolygon::convert(jni::JNIEnv &env, jni::Obje
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 jPointListsListList = MultiPolygon::coordinates(env, jMultiPolygon);
auto jPointListsListArray = java::util::List::toArray<java::util::List>(env, jPointListsListList);
auto size = jPositionListsListArray.Length(env);
auto size = jPointListsListArray.Length(env);
multiPolygon.reserve(size);
for (size_t i = 0; i < size; i++) {
auto jPositionListsList = jPositionListsListArray.Get(env, i);
auto jPositionListsList = jPointListsListArray.Get(env, i);
multiPolygon.push_back(Polygon::convert(env, jPositionListsList));
jni::DeleteLocalRef(env, jPositionListsList);
}
jni::DeleteLocalRef(env, jPositionListsListList);
jni::DeleteLocalRef(env, jPositionListsListArray);
jni::DeleteLocalRef(env, jPointListsListList);
jni::DeleteLocalRef(env, jPointListsListArray);
}
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");
jni::Object<java::util::List> MultiPolygon::coordinates(jni::JNIEnv &env, jni::Object<MultiPolygon> jPolygon) {
static auto method = MultiPolygon::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
return jPolygon.Call(env, method);
}

4
platform/android/src/geojson/multi_polygon.hpp
View File

@@ -13,13 +13,13 @@ namespace geojson {
class MultiPolygon : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/services/commons/geojson/MultiPolygon"; };
static constexpr auto Name() { return "com/mapbox/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::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<MultiPolygon>);
static jni::Class<MultiPolygon> javaClass;

34
platform/android/src/geojson/point.cpp
View File

@@ -1,19 +1,41 @@
#include "point.hpp"
#include "../java/util.hpp"
#include "../java_types.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);
mapbox::geojson::point point;
if (jPoint) {
auto jDoubleList = Point::coordinates(env, jPoint);
point = Point::convert(env, jDoubleList);
jni::DeleteLocalRef(env, jDoubleList);
}
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);
mapbox::geojson::point Point::convert(jni::JNIEnv &env, jni::Object<java::util::List/*<Double>*/> jDoubleList) {
auto jDoubleArray = java::util::List::toArray<double>(env, jDoubleList);
jni::jdouble lon = jni::CallMethod<jni::jdouble>(env,
jDoubleArray.Get(env, 0),
*java::Number::doubleValueMethodId);
jni::jdouble lat = jni::CallMethod<jni::jdouble>(env,
jDoubleArray.Get(env, 1),
*java::Number::doubleValueMethodId);
mapbox::geojson::point point(lon, lat);
jni::DeleteLocalRef(env, jDoubleArray);
return point;
}
jni::Object<java::util::List> Point::coordinates(jni::JNIEnv &env, jni::Object<Point> jPoint) {
static auto method = Point::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
return jPoint.Call(env, method);
}
void Point::registerNative(jni::JNIEnv &env) {

10
platform/android/src/geojson/point.hpp
View File

@@ -3,23 +3,25 @@
#include <mbgl/util/geojson.hpp>
#include <mbgl/util/noncopyable.hpp>
#include "position.hpp"
#include <jni/jni.hpp>
#include "../java/util.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 Name() { return "com/mapbox/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 mapbox::geojson::point convert(jni::JNIEnv&, jni::Object<java::util::List/*<Double>*/>);
static jni::Object<java::util::List> coordinates(JNIEnv&, jni::Object<Point>);
static jni::Class<Point> javaClass;

12
platform/android/src/geojson/polygon.cpp
View File

@@ -12,7 +12,7 @@ mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, jni::Object<Polygon>
mapbox::geojson::polygon polygon;
if (jPolygon) {
auto jPositionListsList = Polygon::getCoordinates(env, jPolygon);
auto jPositionListsList = Polygon::coordinates(env, jPolygon);
polygon = Polygon::convert(env, jPositionListsList);
jni::DeleteLocalRef(env, jPositionListsList);
}
@@ -20,11 +20,11 @@ mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, jni::Object<Polygon>
return polygon;
}
mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, jni::Object<java::util::List/*<java::util::List<Position>>*/> jPositionListsList) {
mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, jni::Object<java::util::List/*<java::util::List<Point>>*/> jPointListsList) {
mapbox::geojson::polygon polygon;
if (jPositionListsList) {
auto multiLine = MultiLineString::convert(env, jPositionListsList);
if (jPointListsList) {
auto multiLine = MultiLineString::convert(env, jPointListsList);
polygon.reserve(multiLine.size());
for (auto&& line : multiLine) {
polygon.emplace_back(convertExplicit<mapbox::geojson::linear_ring>(std::move(line)));
@@ -35,8 +35,8 @@ mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, jni::Object<java::ut
}
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");
jni::Object<java::util::List> Polygon::coordinates(jni::JNIEnv &env, jni::Object<Polygon> jPolygon) {
static auto method = Polygon::javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
return jPolygon.Call(env, method);
}

6
platform/android/src/geojson/polygon.hpp
View File

@@ -13,15 +13,15 @@ namespace geojson {
class Polygon : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/services/commons/geojson/Polygon"; };
static constexpr auto Name() { return "com/mapbox/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 mapbox::geojson::polygon convert(jni::JNIEnv&, jni::Object<java::util::List/*<java::util::List<Point>>*/>);
static jni::Object<java::util::List> getCoordinates(jni::JNIEnv&, jni::Object<Polygon>);
static jni::Object<java::util::List> coordinates(jni::JNIEnv&, jni::Object<Polygon>);
static jni::Class<Polygon> javaClass;

27
platform/android/src/geojson/position.cpp
View File

@@ -1,27 +0,0 @@
#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

27
platform/android/src/geojson/position.hpp
View File

@@ -1,27 +0,0 @@
#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

2
platform/android/src/jni.cpp
View File

@@ -20,7 +20,6 @@
#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/lat_lng_quad.hpp"
@@ -128,7 +127,6 @@ void registerNatives(JavaVM *vm) {
geojson::MultiPolygon::registerNative(env);
geojson::Point::registerNative(env);
geojson::Polygon::registerNative(env);
geojson::Position::registerNative(env);
// Geometry
LatLng::registerNative(env);