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

Add clang-format (#1086)

Browse Source 
Co-authored-by: mwilsnd <mwilsnd@gmail.com>
This commit is contained in:
Bart Louwers
2023-05-01 16:57:37 +02:00
committed by GitHub
parent 403a12bd1b
commit 71f6da2722
1018 changed files with 27876 additions and 25862 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
platform/android/MapboxGLAndroidSDK/src/cpp/android_renderer_backend.cpp Executable file → Normal file
View File

@@ -13,8 +13,8 @@ namespace android {
class AndroidGLRenderableResource final : public mbgl::gl::RenderableResource {
public:
AndroidGLRenderableResource(AndroidRendererBackend& backend_) : backend(backend_) {
}
AndroidGLRenderableResource(AndroidRendererBackend& backend_)
: backend(backend_) {}
void bind() override {
assert(gfx::BackendScope::exists());
@@ -28,8 +28,7 @@ private:
AndroidRendererBackend::AndroidRendererBackend()
: gl::RendererBackend(gfx::ContextMode::Unique),
mbgl::gfx::Renderable({ 64, 64 }, std::make_unique<AndroidGLRenderableResource>(*this)) {
}
mbgl::gfx::Renderable({64, 64}, std::make_unique<AndroidGLRenderableResource>(*this)) {}
AndroidRendererBackend::~AndroidRendererBackend() = default;
@@ -44,7 +43,7 @@ void AndroidRendererBackend::updateViewPort() {
}
void AndroidRendererBackend::resizeFramebuffer(int width, int height) {
size = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
size = {static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
}
PremultipliedImage AndroidRendererBackend::readFramebuffer() {
@@ -64,4 +63,4 @@ void AndroidRendererBackend::markContextLost() {
}
} // namespace android
} // namspace mbgl
} // namespace mbgl

4
platform/android/MapboxGLAndroidSDK/src/cpp/android_renderer_backend.hpp Executable file → Normal file
View File

@@ -21,9 +21,7 @@ public:
// mbgl::gfx::RendererBackend implementation
public:
mbgl::gfx::Renderable& getDefaultRenderable() override {
return *this;
}
mbgl::gfx::Renderable& getDefaultRenderable() override { return *this; }
protected:
void activate() override {

68
platform/android/MapboxGLAndroidSDK/src/cpp/android_renderer_frontend.cpp
View File

@@ -18,37 +18,24 @@ namespace android {
class ForwardingRendererObserver : public RendererObserver {
public:
ForwardingRendererObserver(util::RunLoop& mapRunLoop, RendererObserver& delegate_)
: mailbox(std::make_shared<Mailbox>(mapRunLoop))
, delegate(delegate_, mailbox) {
}
: mailbox(std::make_shared<Mailbox>(mapRunLoop)),
delegate(delegate_, mailbox) {}
~ForwardingRendererObserver() {
mailbox->close();
}
~ForwardingRendererObserver() { mailbox->close(); }
void onInvalidate() override {
delegate.invoke(&RendererObserver::onInvalidate);
}
void onInvalidate() override { delegate.invoke(&RendererObserver::onInvalidate); }
void onResourceError(std::exception_ptr err) override {
delegate.invoke(&RendererObserver::onResourceError, err);
}
void onResourceError(std::exception_ptr err) override { delegate.invoke(&RendererObserver::onResourceError, err); }
void onWillStartRenderingMap() override {
delegate.invoke(&RendererObserver::onWillStartRenderingMap);
}
void onWillStartRenderingMap() override { delegate.invoke(&RendererObserver::onWillStartRenderingMap); }
void onWillStartRenderingFrame() override {
delegate.invoke(&RendererObserver::onWillStartRenderingFrame);
}
void onWillStartRenderingFrame() override { delegate.invoke(&RendererObserver::onWillStartRenderingFrame); }
void onDidFinishRenderingFrame(RenderMode mode, bool repaintNeeded, bool placementChanged) override {
delegate.invoke(&RendererObserver::onDidFinishRenderingFrame, mode, repaintNeeded, placementChanged);
}
void onDidFinishRenderingMap() override {
delegate.invoke(&RendererObserver::onDidFinishRenderingMap);
}
void onDidFinishRenderingMap() override { delegate.invoke(&RendererObserver::onDidFinishRenderingMap); }
void onStyleImageMissing(const std::string& id, const StyleImageMissingCallback& done) override {
delegate.invoke(&RendererObserver::onStyleImageMissing, id, done);
@@ -64,13 +51,12 @@ private:
};
AndroidRendererFrontend::AndroidRendererFrontend(MapRenderer& mapRenderer_)
: mapRenderer(mapRenderer_)
, mapRunLoop(util::RunLoop::Get())
, updateAsyncTask(std::make_unique<util::AsyncTask>([this]() {
mapRenderer.update(std::move(updateParams));
mapRenderer.requestRender();
})) {
}
: mapRenderer(mapRenderer_),
mapRunLoop(util::RunLoop::Get()),
updateAsyncTask(std::make_unique<util::AsyncTask>([this]() {
mapRenderer.update(std::move(updateParams));
mapRenderer.requestRender();
})) {}
AndroidRendererFrontend::~AndroidRendererFrontend() = default;
@@ -79,7 +65,7 @@ void AndroidRendererFrontend::reset() {
}
void AndroidRendererFrontend::setObserver(RendererObserver& observer) {
assert (util::RunLoop::Get());
assert(util::RunLoop::Get());
// Don't call the Renderer directly, but use MapRenderer#setObserver to make sure
// the Renderer may be re-initialised without losing the RendererObserver reference.
mapRenderer.setObserver(std::make_unique<ForwardingRendererObserver>(*mapRunLoop, observer));
@@ -102,9 +88,9 @@ std::vector<Feature> AndroidRendererFrontend::querySourceFeatures(const std::str
std::vector<Feature> AndroidRendererFrontend::queryRenderedFeatures(const ScreenBox& box,
const RenderedQueryOptions& options) const {
// Select the right overloaded method
std::vector<Feature> (Renderer::*fn)(const ScreenBox&, const RenderedQueryOptions&) const = &Renderer::queryRenderedFeatures;
std::vector<Feature> (Renderer::*fn)(const ScreenBox&, const RenderedQueryOptions&)
const = &Renderer::queryRenderedFeatures;
// Waits for the result from the orchestration thread and returns
return mapRenderer.actor().ask(fn, box, options).get();
@@ -112,9 +98,9 @@ std::vector<Feature> AndroidRendererFrontend::queryRenderedFeatures(const Screen
std::vector<Feature> AndroidRendererFrontend::queryRenderedFeatures(const ScreenCoordinate& point,
const RenderedQueryOptions& options) const {
// Select the right overloaded method
std::vector<Feature> (Renderer::*fn)(const ScreenCoordinate&, const RenderedQueryOptions&) const = &Renderer::queryRenderedFeatures;
std::vector<Feature> (Renderer::*fn)(const ScreenCoordinate&, const RenderedQueryOptions&)
const = &Renderer::queryRenderedFeatures;
// Waits for the result from the orchestration thread and returns
return mapRenderer.actor().ask(fn, point, options).get();
@@ -130,14 +116,16 @@ AnnotationIDs AndroidRendererFrontend::queryShapeAnnotations(const ScreenBox& bo
return mapRenderer.actor().ask(&Renderer::queryShapeAnnotations, box).get();
}
FeatureExtensionValue AndroidRendererFrontend::queryFeatureExtensions(const std::string& sourceID,
const Feature& feature,
const std::string& extension,
const std::string& extensionField,
const std::optional<std::map<std::string, mbgl::Value>>& args) const {
return mapRenderer.actor().ask(&Renderer::queryFeatureExtensions, sourceID, feature, extension, extensionField, args).get();
FeatureExtensionValue AndroidRendererFrontend::queryFeatureExtensions(
const std::string& sourceID,
const Feature& feature,
const std::string& extension,
const std::string& extensionField,
const std::optional<std::map<std::string, mbgl::Value>>& args) const {
return mapRenderer.actor()
.ask(&Renderer::queryFeatureExtensions, sourceID, feature, extension, extensionField, args)
.get();
}
} // namespace android
} // namespace mbgl

13
platform/android/MapboxGLAndroidSDK/src/cpp/android_renderer_frontend.hpp
View File

@@ -29,7 +29,6 @@ namespace android {
class AndroidRendererFrontend : public RendererFrontend {
public:
AndroidRendererFrontend(MapRenderer&);
~AndroidRendererFrontend() override;
@@ -45,14 +44,12 @@ public:
AnnotationIDs queryPointAnnotations(const ScreenBox& box) const;
AnnotationIDs queryShapeAnnotations(const ScreenBox& box) const;
// Feature extension query
FeatureExtensionValue
queryFeatureExtensions(const std::string& sourceID,
const Feature& feature,
const std::string& extension,
const std::string& extensionField,
const std::optional<std::map<std::string, mbgl::Value>>& args) const;
FeatureExtensionValue queryFeatureExtensions(const std::string& sourceID,
const Feature& feature,
const std::string& extension,
const std::string& extensionField,
const std::optional<std::map<std::string, mbgl::Value>>& args) const;
// Memory
void reduceMemoryUse();

3
platform/android/MapboxGLAndroidSDK/src/cpp/annotation/marker.hpp
View File

@@ -12,7 +12,6 @@ namespace android {
class Marker : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/annotations/Marker"; };
static mbgl::Point<double> getPosition(jni::JNIEnv&, const jni::Object<Marker>&);
@@ -20,9 +19,7 @@ public:
static std::string getIconId(jni::JNIEnv&, const jni::Object<Marker>&);
static void registerNative(jni::JNIEnv&);
};
} // namespace android
} // namespace mbgl

24
platform/android/MapboxGLAndroidSDK/src/cpp/annotation/multi_point.hpp
View File

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

6
platform/android/MapboxGLAndroidSDK/src/cpp/annotation/polygon.cpp
View File

@@ -13,9 +13,7 @@ mbgl::FillAnnotation Polygon::toAnnotation(jni::JNIEnv& env, const jni::Object<P
static auto fillColor = javaClass.GetField<int>(env, "fillColor");
static auto strokeColor = javaClass.GetField<int>(env, "strokeColor");
mbgl::Polygon<double> geometry {
MultiPoint::toGeometry<mbgl::LinearRing<double>>(env, polygon.Get(env, points))
};
mbgl::Polygon<double> geometry{MultiPoint::toGeometry<mbgl::LinearRing<double>>(env, polygon.Get(env, points))};
auto jHoleListsArray = java::util::List::toArray<java::util::List>(env, polygon.Get(env, holes));
@@ -24,7 +22,7 @@ mbgl::FillAnnotation Polygon::toAnnotation(jni::JNIEnv& env, const jni::Object<P
geometry.push_back(MultiPoint::toGeometry<mbgl::LinearRing<double>>(env, jHoleListsArray.Get(env, i)));
}
mbgl::FillAnnotation annotation { geometry };
mbgl::FillAnnotation annotation{geometry};
annotation.opacity = polygon.Get(env, alpha);
annotation.color = *conversion::convert<mbgl::Color>(env, polygon.Get(env, fillColor));
annotation.outlineColor = *conversion::convert<mbgl::Color>(env, polygon.Get(env, strokeColor));

1
platform/android/MapboxGLAndroidSDK/src/cpp/annotation/polygon.hpp
View File

@@ -16,6 +16,5 @@ public:
static void registerNative(jni::JNIEnv&);
};
} // namespace android
} // namespace mbgl

4
platform/android/MapboxGLAndroidSDK/src/cpp/annotation/polyline.cpp
View File

@@ -12,9 +12,7 @@ mbgl::LineAnnotation Polyline::toAnnotation(jni::JNIEnv& env, const jni::Object<
static auto color = javaClass.GetField<int>(env, "color");
static auto width = javaClass.GetField<float>(env, "width");
mbgl::LineAnnotation annotation {
MultiPoint::toGeometry<mbgl::LineString<double>>(env, polyline.Get(env, points))
};
mbgl::LineAnnotation annotation{MultiPoint::toGeometry<mbgl::LineString<double>>(env, polyline.Get(env, points))};
annotation.opacity = polyline.Get(env, alpha);
annotation.color = *conversion::convert<mbgl::Color>(env, polyline.Get(env, color));

1
platform/android/MapboxGLAndroidSDK/src/cpp/annotation/polyline.hpp
View File

@@ -16,6 +16,5 @@ public:
static void registerNative(jni::JNIEnv&);
};
} // namespace android
} // namespace mbgl

4
platform/android/MapboxGLAndroidSDK/src/cpp/asset_manager.hpp
View File

@@ -5,9 +5,7 @@ namespace android {
class AssetManager {
public:
static constexpr auto Name() {
return "android/content/res/AssetManager";
};
static constexpr auto Name() { return "android/content/res/AssetManager"; };
};
} // namespace android

31
platform/android/MapboxGLAndroidSDK/src/cpp/asset_manager_file_source.cpp
View File

@@ -16,10 +16,13 @@ namespace mbgl {
class AssetManagerFileSource::Impl {
public:
Impl(ActorRef<Impl>, AAssetManager* assetManager_, const ResourceOptions resourceOptions_, const ClientOptions clientOptions_) :
resourceOptions(resourceOptions_.clone()),
clientOptions(clientOptions_.clone()),
assetManager(assetManager_) {}
Impl(ActorRef<Impl>,
AAssetManager* assetManager_,
const ResourceOptions resourceOptions_,
const ClientOptions clientOptions_)
: resourceOptions(resourceOptions_.clone()),
clientOptions(clientOptions_.clone()),
assetManager(assetManager_) {}
void request(const std::string& url, ActorRef<FileSourceRequest> req) {
// Note: AssetManager already prepends "assets" to the filename.
@@ -28,8 +31,8 @@ public:
Response response;
if (AAsset* asset = AAssetManager_open(assetManager, path.c_str(), AASSET_MODE_BUFFER)) {
response.data = std::make_shared<std::string>(
reinterpret_cast<const char*>(AAsset_getBuffer(asset)), AAsset_getLength64(asset));
response.data = std::make_shared<std::string>(reinterpret_cast<const char*>(AAsset_getBuffer(asset)),
AAsset_getLength64(asset));
AAsset_close(asset);
} else {
response.error = std::make_unique<Response::Error>(Response::Error::Reason::NotFound,
@@ -39,21 +42,13 @@ public:
req.invoke(&FileSourceRequest::setResponse, response);
}
void setResourceOptions(ResourceOptions options) {
resourceOptions = options;
}
void setResourceOptions(ResourceOptions options) { resourceOptions = options; }
ResourceOptions getResourceOptions() {
return resourceOptions.clone();
}
ResourceOptions getResourceOptions() { return resourceOptions.clone(); }
void setClientOptions(ClientOptions options) {
clientOptions = options;
}
void setClientOptions(ClientOptions options) { clientOptions = options; }
ClientOptions getClientOptions() {
return clientOptions.clone();
}
ClientOptions getClientOptions() { return clientOptions.clone(); }
private:
AAssetManager* assetManager;

8
platform/android/MapboxGLAndroidSDK/src/cpp/asset_manager_file_source.hpp
View File

@@ -11,12 +11,16 @@
namespace mbgl {
namespace util {
template <typename T> class Thread;
template <typename T>
class Thread;
} // namespace util
class AssetManagerFileSource : public FileSource {
public:
AssetManagerFileSource(jni::JNIEnv&, const jni::Object<android::AssetManager>&, const ResourceOptions, const ClientOptions);
AssetManagerFileSource(jni::JNIEnv&,
const jni::Object<android::AssetManager>&,
const ResourceOptions,
const ClientOptions);
~AssetManagerFileSource() override;
std::unique_ptr<AsyncRequest> request(const Resource&, Callback) override;

45
platform/android/MapboxGLAndroidSDK/src/cpp/connectivity_listener.cpp
View File

@@ -8,34 +8,33 @@
namespace mbgl {
namespace android {
/**
* Invoked when the construction is initiated from the jvm
*/
ConnectivityListener::ConnectivityListener(jni::JNIEnv&) {}
/**
* Invoked when the construction is initiated from the jvm
*/
ConnectivityListener::ConnectivityListener(jni::JNIEnv&) {}
ConnectivityListener::~ConnectivityListener() {}
ConnectivityListener::~ConnectivityListener() {}
void ConnectivityListener::onConnectivityStateChanged(jni::JNIEnv&, jni::jboolean connected) {
NetworkStatus::Set(connected ? NetworkStatus::Status::Online : NetworkStatus::Status::Offline);
}
void ConnectivityListener::onConnectivityStateChanged(jni::JNIEnv&, jni::jboolean connected) {
NetworkStatus::Set(connected ? NetworkStatus::Status::Online : NetworkStatus::Status::Offline);
}
void ConnectivityListener::registerNative(jni::JNIEnv& env) {
// Lookup the class
static auto& javaClass = jni::Class<ConnectivityListener>::Singleton(env);
void ConnectivityListener::registerNative(jni::JNIEnv& env) {
// Lookup the class
static auto& javaClass = jni::Class<ConnectivityListener>::Singleton(env);
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
// Register the peer
jni::RegisterNativePeer<ConnectivityListener>(
env,
javaClass,
"nativePtr",
std::make_unique<ConnectivityListener, JNIEnv&>,
"initialize",
"finalize",
METHOD(&ConnectivityListener::onConnectivityStateChanged, "nativeOnConnectivityStateChanged")
);
}
// Register the peer
jni::RegisterNativePeer<ConnectivityListener>(
env,
javaClass,
"nativePtr",
std::make_unique<ConnectivityListener, JNIEnv&>,
"initialize",
"finalize",
METHOD(&ConnectivityListener::onConnectivityStateChanged, "nativeOnConnectivityStateChanged"));
}
} // namespace android
} // namespace mbgl

2
platform/android/MapboxGLAndroidSDK/src/cpp/connectivity_listener.hpp
View File

@@ -9,7 +9,6 @@ namespace android {
class ConnectivityListener : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/net/NativeConnectivityListener"; };
static void registerNative(jni::JNIEnv&);
@@ -22,7 +21,6 @@ public:
~ConnectivityListener();
void onConnectivityStateChanged(jni::JNIEnv&, jni::jboolean);
};
} // namespace android

6
platform/android/MapboxGLAndroidSDK/src/cpp/conversion/collection.cpp
View File

@@ -27,6 +27,6 @@ jni::Local<jni::Array<jni::String>> toArray(JNIEnv& env, const std::vector<std::
return result;
}
}
}
}
} // namespace conversion
} // namespace android
} // namespace mbgl

6
platform/android/MapboxGLAndroidSDK/src/cpp/conversion/collection.hpp
View File

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

6
platform/android/MapboxGLAndroidSDK/src/cpp/conversion/color.cpp
View File

@@ -7,11 +7,11 @@ namespace conversion {
Result<mbgl::Color> Converter<mbgl::Color, int>::operator()(jni::JNIEnv&, const int& color) const {
float r = (color >> 16) & 0xFF;
float g = (color >> 8) & 0xFF;
float b = (color) & 0xFF;
float b = (color)&0xFF;
float a = (color >> 24) & 0xFF;
return { mbgl::Color( r / 255.0f, g / 255.0f, b / 255.0f, a / 255.0f ) };
return {mbgl::Color(r / 255.0f, g / 255.0f, b / 255.0f, a / 255.0f)};
}
} // namespace conversion
} // namespace style
} // namespace android
} // namespace mbgl

2
platform/android/MapboxGLAndroidSDK/src/cpp/conversion/color.hpp
View File

@@ -14,5 +14,5 @@ struct Converter<mbgl::Color, int> {
};
} // namespace conversion
} // namespace style
} // namespace android
} // namespace mbgl

32
platform/android/MapboxGLAndroidSDK/src/cpp/conversion/constant.cpp
View File

@@ -8,31 +8,38 @@ namespace mbgl {
namespace android {
namespace conversion {
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, bool>::operator()(jni::JNIEnv& env, const bool& value) const {
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, bool>::operator()(jni::JNIEnv& env,
const bool& value) const {
return jni::Box(env, value ? jni::jni_true : jni::jni_false);
}
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, float>::operator()(jni::JNIEnv& env, const float& value) const {
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, float>::operator()(jni::JNIEnv& env,
const float& value) const {
return jni::Box(env, value);
}
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, double>::operator()(jni::JNIEnv& env, const double& value) const {
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, double>::operator()(jni::JNIEnv& env,
const double& value) const {
return jni::Box(env, value);
}
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::string>::operator()(jni::JNIEnv& env, const std::string& value) const {
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::string>::operator()(
jni::JNIEnv& env, const std::string& value) const {
return jni::Make<jni::String>(env, value);
}
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, Color>::operator()(jni::JNIEnv& env, const Color& value) const {
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, Color>::operator()(jni::JNIEnv& env,
const Color& value) const {
return jni::Make<jni::String>(env, value.stringify());
}
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, style::expression::Formatted>::operator()(jni::JNIEnv& env, const style::expression::Formatted& value) const {
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, style::expression::Formatted>::operator()(
jni::JNIEnv& env, const style::expression::Formatted& value) const {
return Formatted::New(env, value);
}
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vector<std::string>>::operator()(jni::JNIEnv& env, const std::vector<std::string>& value) const {
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vector<std::string>>::operator()(
jni::JNIEnv& env, const std::vector<std::string>& value) const {
auto result = jni::Array<jni::String>::New(env, value.size());
for (std::size_t i = 0; i < value.size(); i++) {
@@ -42,7 +49,8 @@ Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vect
return result;
}
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vector<float>>::operator()(jni::JNIEnv& env, const std::vector<float>& value) const {
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vector<float>>::operator()(
jni::JNIEnv& env, const std::vector<float>& value) const {
auto result = jni::Array<jni::Float>::New(env, value.size());
for (std::size_t i = 0; i < value.size(); i++) {
@@ -52,7 +60,8 @@ Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vect
return result;
}
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vector<double>>::operator()(jni::JNIEnv& env, const std::vector<double>& value) const {
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vector<double>>::operator()(
jni::JNIEnv& env, const std::vector<double>& value) const {
auto result = jni::Array<jni::Double>::New(env, value.size());
for (std::size_t i = 0; i < value.size(); i++) {
@@ -67,10 +76,11 @@ Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, style::ex
return jni::Make<jni::String>(env, value.id());
}
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, mbgl::style::Rotation>::operator()(jni::JNIEnv& env, const mbgl::style::Rotation& value) const {
Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, mbgl::style::Rotation>::operator()(
jni::JNIEnv& env, const mbgl::style::Rotation& value) const {
return jni::Box(env, value.getAngle());
}
} // namespace conversion
} // namespace style
} // namespace android
} // namespace mbgl

2
platform/android/MapboxGLAndroidSDK/src/cpp/conversion/constant.hpp
View File

@@ -38,7 +38,7 @@ struct Converter<jni::Local<jni::Object<>>, double> {
* All integrals. java is limited to 64 bit signed, so...
* TODO: use BigDecimal for > 64 / unsigned?
*/
template<typename T>
template <typename T>
struct Converter<jni::Local<jni::Object<>>, T, typename std::enable_if<std::is_integral<T>::value>::type> {
Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const T& value) const {
return jni::Box(env, jni::jlong(value));

12
platform/android/MapboxGLAndroidSDK/src/cpp/conversion/conversion.hpp
View File

@@ -10,16 +10,16 @@ namespace mbgl {
namespace android {
namespace conversion {
struct Error { std::string message; };
struct Error {
std::string message;
};
template <class T>
class Result : private variant<T, Error> {
public:
using variant<T, Error>::variant;
explicit operator bool() const {
return this->template is<T>();
}
explicit operator bool() const { return this->template is<T>(); }
T& operator*() {
assert(this->template is<T>());
@@ -40,8 +40,8 @@ public:
template <class T, class V, class Enable = void>
struct Converter;
template <class T, typename V, class...Args>
Result<T> convert(jni::JNIEnv& env, const V& value, Args&&...args) {
template <class T, typename V, class... Args>
Result<T> convert(jni::JNIEnv& env, const V& value, Args&&... args) {
return Converter<T, V>()(env, value, std::forward<Args>(args)...);
}

119
platform/android/MapboxGLAndroidSDK/src/cpp/file_source.cpp
View File

@@ -20,39 +20,43 @@ namespace android {
// FileSource //
FileSource::FileSource(jni::JNIEnv& _env, const jni::String& apiKey, const jni::String& _cachePath, const jni::Object<TileServerOptions>& _options)
:activationCounter( std::optional<int>(1)) {
FileSource::FileSource(jni::JNIEnv& _env,
const jni::String& apiKey,
const jni::String& _cachePath,
const jni::Object<TileServerOptions>& _options)
: activationCounter(std::optional<int>(1)) {
std::string path = jni::Make<std::string>(_env, _cachePath);
mapbox::sqlite::setTempPath(path);
mbgl::FileSourceManager::get()->registerFileSourceFactory(
mbgl::FileSourceType::Asset, [](const mbgl::ResourceOptions& resourceOptions, const mbgl::ClientOptions& clientOptions) {
mbgl::FileSourceType::Asset,
[](const mbgl::ResourceOptions& resourceOptions, const mbgl::ClientOptions& clientOptions) {
auto env{android::AttachEnv()};
std::unique_ptr<mbgl::FileSource> assetFileSource;
if (android::Mapbox::hasInstance(*env)) {
auto assetManager = android::Mapbox::getAssetManager(*env);
assetFileSource = std::make_unique<AssetManagerFileSource>(*env, assetManager, resourceOptions.clone(), clientOptions.clone());
assetFileSource = std::make_unique<AssetManagerFileSource>(
*env, assetManager, resourceOptions.clone(), clientOptions.clone());
}
return assetFileSource;
});
auto tileServerOptions = TileServerOptions::getTileServerOptions(_env, _options);
resourceOptions
.withTileServerOptions(tileServerOptions)
.withApiKey(apiKey ? jni::Make<std::string>(_env, apiKey) : "")
.withCachePath(path + DATABASE_FILE);
resourceOptions.withTileServerOptions(tileServerOptions)
.withApiKey(apiKey ? jni::Make<std::string>(_env, apiKey) : "")
.withCachePath(path + DATABASE_FILE);
// Create a core file sources
// TODO: Split Android FileSource API to smaller interfaces
resourceLoader =
mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::ResourceLoader, resourceOptions, clientOptions);
resourceLoader = mbgl::FileSourceManager::get()->getFileSource(
mbgl::FileSourceType::ResourceLoader, resourceOptions, clientOptions);
databaseSource = std::static_pointer_cast<mbgl::DatabaseFileSource>(std::shared_ptr<mbgl::FileSource>(
mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::Database, resourceOptions, clientOptions)));
onlineSource = mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::Network, resourceOptions, clientOptions);
onlineSource = mbgl::FileSourceManager::get()->getFileSource(
mbgl::FileSourceType::Network, resourceOptions, clientOptions);
}
FileSource::~FileSource() {
}
FileSource::~FileSource() {}
void FileSource::setTileServerOptions(jni::JNIEnv& _env, const jni::Object<TileServerOptions>& _options) {
auto tileServerOptions = TileServerOptions::getTileServerOptions(_env, _options);
@@ -96,7 +100,8 @@ jni::Local<jni::String> FileSource::getAPIBaseUrl(jni::JNIEnv& env) {
return jni::Make<jni::String>(env, "");
}
void FileSource::setResourceTransform(jni::JNIEnv& env, const jni::Object<FileSource::ResourceTransformCallback>& transformCallback) {
void FileSource::setResourceTransform(jni::JNIEnv& env,
const jni::Object<FileSource::ResourceTransformCallback>& transformCallback) {
// Core could be built without support for network resource provider.
if (!onlineSource) {
ThrowNew(env, jni::FindClass(env, "java/lang/IllegalStateException"), "Online functionality is disabled.");
@@ -107,11 +112,12 @@ void FileSource::setResourceTransform(jni::JNIEnv& env, const jni::Object<FileSo
auto global = jni::NewGlobal<jni::EnvAttachingDeleter>(env, transformCallback);
resourceTransform = std::make_unique<Actor<ResourceTransform::TransformCallback>>(
*Scheduler::GetCurrent(),
// Capture the ResourceTransformCallback object as a managed global into
// the lambda. It is released automatically when we're setting a new ResourceTransform in
// a subsequent call.
// Note: we're converting it to shared_ptr because this lambda is converted to a std::function,
// which requires copyability of its captured variables.
// Capture the ResourceTransformCallback object as a managed
// global into the lambda. It is released automatically when
// we're setting a new ResourceTransform in a subsequent call.
// Note: we're converting it to shared_ptr because this lambda
// is converted to a std::function, which requires copyability
// of its captured variables.
[callback = std::make_shared<decltype(global)>(std::move(global))](
mbgl::Resource::Kind kind, const std::string& url_, ResourceTransform::FinishedCallback cb) {
android::UniqueEnv _env = android::AttachEnv();
@@ -138,7 +144,8 @@ void FileSource::setResourceCachePath(jni::JNIEnv& env,
}
if (pathChangeCallback) {
FileSource::ResourcesCachePathChangeCallback::onError(env, _callback, jni::Make<jni::String>(env, "Another resources cache path change is in progress"));
FileSource::ResourcesCachePathChangeCallback::onError(
env, _callback, jni::Make<jni::String>(env, "Another resources cache path change is in progress"));
return;
}
@@ -179,14 +186,14 @@ void FileSource::pause(jni::JNIEnv&) {
}
}
jni::jboolean FileSource::isResumed(jni::JNIEnv &) {
return (jboolean) (activationCounter > 0);
jni::jboolean FileSource::isResumed(jni::JNIEnv&) {
return (jboolean)(activationCounter > 0);
}
FileSource* FileSource::getNativePeer(jni::JNIEnv& env, const jni::Object<FileSource>& jFileSource) {
static auto& javaClass = jni::Class<FileSource>::Singleton(env);
static auto field = javaClass.GetField<jlong>(env, "nativePtr");
return reinterpret_cast<FileSource *>(jFileSource.Get(env, field));
return reinterpret_cast<FileSource*>(jFileSource.Get(env, field));
}
mbgl::ResourceOptions FileSource::getSharedResourceOptions(jni::JNIEnv& env,
@@ -200,8 +207,7 @@ mbgl::ResourceOptions FileSource::getSharedResourceOptions(jni::JNIEnv& env,
return {};
}
mbgl::ClientOptions FileSource::getSharedClientOptions(jni::JNIEnv& env,
const jni::Object<FileSource>& jFileSource) {
mbgl::ClientOptions FileSource::getSharedClientOptions(jni::JNIEnv& env, const jni::Object<FileSource>& jFileSource) {
FileSource* fileSource = FileSource::getNativePeer(env, jFileSource);
// Core could be compiled without support for any sources.
if (fileSource) {
@@ -213,20 +219,22 @@ mbgl::ClientOptions FileSource::getSharedClientOptions(jni::JNIEnv& env,
// FileSource::ResourcesCachePathChangeCallback //
void FileSource::ResourcesCachePathChangeCallback::onSuccess(jni::JNIEnv& env,
const jni::Object<FileSource::ResourcesCachePathChangeCallback>& callback,
const jni::String& path) {
void FileSource::ResourcesCachePathChangeCallback::onSuccess(
jni::JNIEnv& env,
const jni::Object<FileSource::ResourcesCachePathChangeCallback>& callback,
const jni::String& path) {
static auto& javaClass = jni::Class<FileSource::ResourcesCachePathChangeCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::String)>(env, "onSuccess");
static auto method = javaClass.GetMethod<void(jni::String)>(env, "onSuccess");
callback.Call(env, method, path);
}
void FileSource::ResourcesCachePathChangeCallback::onError(jni::JNIEnv& env,
const jni::Object<FileSource::ResourcesCachePathChangeCallback>& callback,
const jni::String& message) {
void FileSource::ResourcesCachePathChangeCallback::onError(
jni::JNIEnv& env,
const jni::Object<FileSource::ResourcesCachePathChangeCallback>& callback,
const jni::String& message) {
static auto& javaClass = jni::Class<FileSource::ResourcesCachePathChangeCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
static auto method = javaClass.GetMethod<void(jni::String)>(env, "onError");
callback.Call(env, method, message);
}
@@ -240,37 +248,36 @@ void FileSource::registerNative(jni::JNIEnv& env) {
static auto& javaClass = jni::Class<FileSource>::Singleton(env);
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
// Register the peer
jni::RegisterNativePeer<FileSource>(env,
javaClass,
"nativePtr",
jni::MakePeer<FileSource, const jni::String&, const jni::String&, const jni::Object<TileServerOptions>&>,
"initialize",
"finalize",
METHOD(&FileSource::setTileServerOptions, "setTileServerOptions"),
METHOD(&FileSource::getApiKey, "getApiKey"),
METHOD(&FileSource::setApiKey, "setApiKey"),
METHOD(&FileSource::setAPIBaseUrl, "setApiBaseUrl"),
METHOD(&FileSource::getAPIBaseUrl, "getApiBaseUrl"),
METHOD(&FileSource::setResourceTransform, "setResourceTransform"),
METHOD(&FileSource::setResourceCachePath, "setResourceCachePath"),
METHOD(&FileSource::resume, "activate"),
METHOD(&FileSource::pause, "deactivate"),
METHOD(&FileSource::isResumed, "isActivated"));
jni::RegisterNativePeer<FileSource>(
env,
javaClass,
"nativePtr",
jni::MakePeer<FileSource, const jni::String&, const jni::String&, const jni::Object<TileServerOptions>&>,
"initialize",
"finalize",
METHOD(&FileSource::setTileServerOptions, "setTileServerOptions"),
METHOD(&FileSource::getApiKey, "getApiKey"),
METHOD(&FileSource::setApiKey, "setApiKey"),
METHOD(&FileSource::setAPIBaseUrl, "setApiBaseUrl"),
METHOD(&FileSource::getAPIBaseUrl, "getApiBaseUrl"),
METHOD(&FileSource::setResourceTransform, "setResourceTransform"),
METHOD(&FileSource::setResourceCachePath, "setResourceCachePath"),
METHOD(&FileSource::resume, "activate"),
METHOD(&FileSource::pause, "deactivate"),
METHOD(&FileSource::isResumed, "isActivated"));
}
// FileSource::ResourceTransformCallback //
std::string FileSource::ResourceTransformCallback::onURL(jni::JNIEnv& env, const jni::Object<FileSource::ResourceTransformCallback>& callback, int kind, std::string url_) {
std::string FileSource::ResourceTransformCallback::onURL(
jni::JNIEnv& env, const jni::Object<FileSource::ResourceTransformCallback>& callback, int kind, std::string url_) {
static auto& javaClass = jni::Class<FileSource::ResourceTransformCallback>::Singleton(env);
static auto method = javaClass.GetMethod<jni::String (jni::jint, jni::String)>(env, "onURL");
static auto method = javaClass.GetMethod<jni::String(jni::jint, jni::String)>(env, "onURL");
return jni::Make<std::string>(env,
callback.Call(env, method, kind,
jni::Make<jni::String>(env, url_)));
return jni::Make<std::string>(env, callback.Call(env, method, kind, jni::Make<jni::String>(env, url_)));
}
} // namespace android

31
platform/android/MapboxGLAndroidSDK/src/cpp/file_source.hpp
View File

@@ -13,35 +13,44 @@
namespace mbgl {
template <typename T> class Actor;
template <typename T>
class Actor;
namespace android {
/**
* Peer class for the Android FileSource holder. Ensures that a single core FileSource
* of a ResourceLoader type is used.
* Peer class for the Android FileSource holder. Ensures that a single core
* FileSource of a ResourceLoader type is used.
*/
class FileSource {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/storage/FileSource"; };
struct ResourceTransformCallback {
static constexpr auto Name() { return "com/mapbox/mapboxsdk/storage/FileSource$ResourceTransformCallback"; }
static constexpr auto Name() {
return "com/mapbox/mapboxsdk/storage/"
"FileSource$ResourceTransformCallback";
}
static std::string onURL(jni::JNIEnv&, const jni::Object<FileSource::ResourceTransformCallback>&, int, std::string);
static std::string onURL(jni::JNIEnv&,
const jni::Object<FileSource::ResourceTransformCallback>&,
int,
std::string);
};
struct ResourcesCachePathChangeCallback {
static constexpr auto Name() { return "com/mapbox/mapboxsdk/storage/FileSource$ResourcesCachePathChangeCallback";}
static constexpr auto Name() {
return "com/mapbox/mapboxsdk/storage/"
"FileSource$ResourcesCachePathChangeCallback";
}
static void onSuccess(jni::JNIEnv&,
const jni::Object<FileSource::ResourcesCachePathChangeCallback>&,
const jni::String&);
static void onError(jni::JNIEnv&,
const jni::Object<FileSource::ResourcesCachePathChangeCallback>&,
const jni::String&);
const jni::Object<FileSource::ResourcesCachePathChangeCallback>&,
const jni::String&);
};
FileSource(jni::JNIEnv&, const jni::String&, const jni::String&, const jni::Object<TileServerOptions>&);
@@ -60,7 +69,9 @@ public:
void setResourceTransform(jni::JNIEnv&, const jni::Object<FileSource::ResourceTransformCallback>&);
void setResourceCachePath(jni::JNIEnv&, const jni::String&, const jni::Object<FileSource::ResourcesCachePathChangeCallback>&);
void setResourceCachePath(jni::JNIEnv&,
const jni::String&,
const jni::Object<FileSource::ResourcesCachePathChangeCallback>&);
void resume(jni::JNIEnv&);

34
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/feature.cpp
View File

@@ -12,9 +12,9 @@ using namespace gson;
mbgl::GeoJSONFeature Feature::convert(jni::JNIEnv& env, const jni::Object<Feature>& jFeature) {
static auto& javaClass = jni::Class<Feature>::Singleton(env);
static auto id = javaClass.GetMethod<jni::String ()>(env, "id");
static auto geometry = javaClass.GetMethod<jni::Object<Geometry> ()>(env, "geometry");
static auto properties = javaClass.GetMethod<jni::Object<gson::JsonObject> ()>(env, "properties");
static auto id = javaClass.GetMethod<jni::String()>(env, "id");
static auto geometry = javaClass.GetMethod<jni::Object<Geometry>()>(env, "geometry");
static auto properties = javaClass.GetMethod<jni::Object<gson::JsonObject>()>(env, "properties");
auto jId = jFeature.Call(env, id);
@@ -30,35 +30,35 @@ mbgl::GeoJSONFeature Feature::convert(jni::JNIEnv& env, const jni::Object<Featur
*/
class FeatureIdVisitor {
public:
template<class T>
template <class T>
std::string operator()(const T& i) const {
return util::toString(i);
}
std::string operator()(const std::string& i) const {
return i;
}
std::string operator()(const std::string& i) const { return i; }
std::string operator()(const std::nullptr_t&) const {
return {};
}
std::string operator()(const std::nullptr_t&) const { return {}; }
std::string operator()(const mapbox::feature::null_value_t&) const {
return {};
}
std::string operator()(const mapbox::feature::null_value_t&) const { return {}; }
};
jni::Local<jni::Object<Feature>> convertFeature(jni::JNIEnv& env, const mbgl::GeoJSONFeature& value) {
static auto& javaClass = jni::Class<Feature>::Singleton(env);
static auto method = javaClass.GetStaticMethod<jni::Object<Feature> (jni::Object<Geometry>, jni::Object<JsonObject>, jni::String)>(env, "fromGeometry");
static auto method =
javaClass.GetStaticMethod<jni::Object<Feature>(jni::Object<Geometry>, jni::Object<JsonObject>, jni::String)>(
env, "fromGeometry");
return javaClass.Call(env, method,
return javaClass.Call(
env,
method,
Geometry::New(env, value.geometry),
JsonObject::New(env, value.properties),
jni::Make<jni::String>(env, value.id.is<mbgl::NullValue>() ? std::string {} : value.id.match(FeatureIdVisitor())));
jni::Make<jni::String>(env,
value.id.is<mbgl::NullValue>() ? std::string{} : value.id.match(FeatureIdVisitor())));
}
jni::Local<jni::Array<jni::Object<Feature>>> Feature::convert(jni::JNIEnv& env, const std::vector<mbgl::Feature>& value) {
jni::Local<jni::Array<jni::Object<Feature>>> Feature::convert(jni::JNIEnv& env,
const std::vector<mbgl::Feature>& value) {
auto features = jni::Array<jni::Object<Feature>>::New(env, value.size());
for (size_t i = 0; i < value.size(); ++i) {

8
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/feature_collection.cpp
View File

@@ -6,7 +6,8 @@ namespace mbgl {
namespace android {
namespace geojson {
mbgl::FeatureCollection FeatureCollection::convert(jni::JNIEnv& env, const jni::Object<FeatureCollection>& jCollection) {
mbgl::FeatureCollection FeatureCollection::convert(jni::JNIEnv& env,
const jni::Object<FeatureCollection>& jCollection) {
auto collection = mbgl::FeatureCollection();
if (jCollection) {
@@ -22,9 +23,10 @@ mbgl::FeatureCollection FeatureCollection::convert(jni::JNIEnv& env, const jni::
return collection;
}
jni::Local<jni::Object<java::util::List>> FeatureCollection::features(jni::JNIEnv& env, const jni::Object<FeatureCollection>& jCollection) {
jni::Local<jni::Object<java::util::List>> FeatureCollection::features(
jni::JNIEnv& env, const jni::Object<FeatureCollection>& jCollection) {
static auto& javaClass = jni::Class<FeatureCollection>::Singleton(env);
static auto method = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "features");
static auto method = javaClass.GetMethod<jni::Object<java::util::List>()>(env, "features");
return jCollection.Call(env, method);
}

38
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/geometry.cpp
View File

@@ -19,8 +19,7 @@ namespace geojson {
*/
class GeometryEvaluator {
public:
jni::JNIEnv& env;
jni::JNIEnv &env;
jni::Local<jni::Object<Geometry>> operator()(const mbgl::EmptyGeometry &) const {
// FIXME: mapbox-java needs to have its own Empty type.
@@ -35,7 +34,7 @@ public:
return LineString::New(env, geometry);
}
jni::Local<jni::Object<Geometry>> operator()(const mbgl::MultiLineString<double> &geometry) const {
jni::Local<jni::Object<Geometry>> operator()(const mbgl::MultiLineString<double> &geometry) const {
return MultiLineString::New(env, geometry);
}
@@ -47,44 +46,45 @@ public:
return Polygon::New(env, geometry);
}
jni::Local<jni::Object<Geometry>> operator()(const mbgl::MultiPolygon<double> &geometry) const {
jni::Local<jni::Object<Geometry>> operator()(const mbgl::MultiPolygon<double> &geometry) const {
return MultiPolygon::New(env, geometry);
}
jni::Local<jni::Object<Geometry>> operator()(const mapbox::geometry::geometry_collection<double> &geometry) const {
jni::Local<jni::Object<Geometry>> operator()(const mapbox::geometry::geometry_collection<double> &geometry) const {
return GeometryCollection::New(env, geometry);
}
};
jni::Local<jni::Object<Geometry>> Geometry::New(jni::JNIEnv& env, mbgl::Geometry<double> geometry) {
GeometryEvaluator evaluator { env } ;
jni::Local<jni::Object<Geometry>> Geometry::New(jni::JNIEnv &env, mbgl::Geometry<double> geometry) {
GeometryEvaluator evaluator{env};
return mbgl::Geometry<double>::visit(geometry, evaluator);
}
mbgl::Geometry<double> Geometry::convert(jni::JNIEnv &env, const jni::Object<Geometry>& jGeometry) {
mbgl::Geometry<double> Geometry::convert(jni::JNIEnv &env, const jni::Object<Geometry> &jGeometry) {
auto type = Geometry::getType(env, jGeometry);
if (type == Point::Type()) {
return { Point::convert(env, jni::Cast(env, jni::Class<Point>::Singleton(env), jGeometry)) };
return {Point::convert(env, jni::Cast(env, jni::Class<Point>::Singleton(env), jGeometry))};
} else if (type == MultiPoint::Type()) {
return { MultiPoint::convert(env, jni::Cast(env, jni::Class<MultiPoint>::Singleton(env), jGeometry)) };
return {MultiPoint::convert(env, jni::Cast(env, jni::Class<MultiPoint>::Singleton(env), jGeometry))};
} else if (type == LineString::Type()) {
return { LineString::convert(env, jni::Cast(env, jni::Class<LineString>::Singleton(env), jGeometry)) };
return {LineString::convert(env, jni::Cast(env, jni::Class<LineString>::Singleton(env), jGeometry))};
} else if (type == MultiLineString::Type()) {
return { MultiLineString::convert(env, jni::Cast(env, jni::Class<MultiLineString>::Singleton(env), jGeometry)) };
return {MultiLineString::convert(env, jni::Cast(env, jni::Class<MultiLineString>::Singleton(env), jGeometry))};
} else if (type == Polygon::Type()) {
return { Polygon::convert(env, jni::Cast(env, jni::Class<Polygon>::Singleton(env), jGeometry)) };
return {Polygon::convert(env, jni::Cast(env, jni::Class<Polygon>::Singleton(env), jGeometry))};
} else if (type == MultiPolygon::Type()) {
return { MultiPolygon::convert(env, jni::Cast(env, jni::Class<MultiPolygon>::Singleton(env), jGeometry)) };
return {MultiPolygon::convert(env, jni::Cast(env, jni::Class<MultiPolygon>::Singleton(env), jGeometry))};
} else if (type == GeometryCollection::Type()) {
return { GeometryCollection::convert(env, jni::Cast(env, jni::Class<GeometryCollection>::Singleton(env), jGeometry)) };
return {GeometryCollection::convert(env,
jni::Cast(env, jni::Class<GeometryCollection>::Singleton(env), jGeometry))};
}
throw std::runtime_error(std::string {"Unsupported GeoJSON type: " } + type);
throw std::runtime_error(std::string{"Unsupported GeoJSON type: "} + type);
}
std::string Geometry::getType(jni::JNIEnv &env, const jni::Object<Geometry>& jGeometry) {
static auto& javaClass = jni::Class<Geometry>::Singleton(env);
static auto method = javaClass.GetMethod<jni::String ()>(env, "type");
std::string Geometry::getType(jni::JNIEnv &env, const jni::Object<Geometry> &jGeometry) {
static auto &javaClass = jni::Class<Geometry>::Singleton(env);
static auto method = javaClass.GetMethod<jni::String()>(env, "type");
return jni::Make<std::string>(env, jGeometry.Call(env, method));
}

13
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/geometry_collection.cpp
View File

@@ -5,7 +5,8 @@ namespace mbgl {
namespace android {
namespace geojson {
jni::Local<jni::Object<GeometryCollection>> GeometryCollection::New(jni::JNIEnv& env, const mapbox::geometry::geometry_collection<double>& collection) {
jni::Local<jni::Object<GeometryCollection>> GeometryCollection::New(
jni::JNIEnv& env, const mapbox::geometry::geometry_collection<double>& collection) {
// Create an array of geometries
auto jarray = jni::Array<jni::Object<Geometry>>::New(env, collection.size());
@@ -15,14 +16,16 @@ jni::Local<jni::Object<GeometryCollection>> GeometryCollection::New(jni::JNIEnv&
// create the GeometryCollection
static auto& javaClass = jni::Class<GeometryCollection>::Singleton(env);
static auto method = javaClass.GetStaticMethod<jni::Object<GeometryCollection> (jni::Object<java::util::List>)>(env, "fromGeometries");
static auto method = javaClass.GetStaticMethod<jni::Object<GeometryCollection>(jni::Object<java::util::List>)>(
env, "fromGeometries");
return javaClass.Call(env, method, java::util::Arrays::asList(env, jarray));
}
mapbox::geometry::geometry_collection<double> GeometryCollection::convert(jni::JNIEnv &env, const jni::Object<GeometryCollection>& jCollection) {
mapbox::geometry::geometry_collection<double> GeometryCollection::convert(
jni::JNIEnv& env, const jni::Object<GeometryCollection>& jCollection) {
// Get geometries
static auto& javaClass = jni::Class<GeometryCollection>::Singleton(env);
static auto getGeometries = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "geometries");
static auto getGeometries = javaClass.GetMethod<jni::Object<java::util::List>()>(env, "geometries");
// Turn into array
auto jarray = java::util::List::toArray<Geometry>(env, jCollection.Call(env, getGeometries));
@@ -38,7 +41,7 @@ mapbox::geometry::geometry_collection<double> GeometryCollection::convert(jni::J
return collection;
}
void GeometryCollection::registerNative(jni::JNIEnv &env) {
void GeometryCollection::registerNative(jni::JNIEnv& env) {
jni::Class<GeometryCollection>::Singleton(env);
}

3
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/geometry_collection.hpp
View File

@@ -14,7 +14,8 @@ public:
static constexpr auto Name() { return "com/mapbox/geojson/GeometryCollection"; };
static constexpr auto Type() { return "GeometryCollection"; };
static jni::Local<jni::Object<GeometryCollection>> New(jni::JNIEnv&, const mapbox::geometry::geometry_collection<double>&);
static jni::Local<jni::Object<GeometryCollection>> New(jni::JNIEnv&,
const mapbox::geometry::geometry_collection<double>&);
static mapbox::geometry::geometry_collection<double> convert(jni::JNIEnv&, const jni::Object<GeometryCollection>&);

15
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/line_string.cpp
View File

@@ -9,12 +9,13 @@ namespace geojson {
jni::Local<jni::Object<LineString>> LineString::New(jni::JNIEnv& env, const mbgl::LineString<double>& lineString) {
static auto& javaClass = jni::Class<LineString>::Singleton(env);
static auto method = javaClass.GetStaticMethod<jni::Object<LineString>(jni::Object<java::util::List>)>(env, "fromLngLats");
static auto method = javaClass.GetStaticMethod<jni::Object<LineString>(jni::Object<java::util::List>)>(
env, "fromLngLats");
return javaClass.Call(env, method, asPointsList(env, lineString));
}
mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, const jni::Object<LineString>& jLineString) {
mapbox::geojson::line_string LineString::convert(jni::JNIEnv& env, const jni::Object<LineString>& jLineString) {
mapbox::geojson::line_string lineString;
if (jLineString) {
@@ -24,7 +25,8 @@ mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, const jni::Ob
return lineString;
}
mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, const jni::Object<java::util::List/*<Point>*/>& jPointList) {
mapbox::geojson::line_string LineString::convert(jni::JNIEnv& env,
const jni::Object<java::util::List /*<Point>*/>& jPointList) {
mapbox::geojson::line_string lineString;
if (jPointList) {
@@ -40,13 +42,14 @@ mapbox::geojson::line_string LineString::convert(jni::JNIEnv &env, const jni::Ob
return lineString;
}
jni::Local<jni::Object<java::util::List>> LineString::coordinates(jni::JNIEnv &env, const jni::Object<LineString>& jLineString) {
jni::Local<jni::Object<java::util::List>> LineString::coordinates(jni::JNIEnv& env,
const jni::Object<LineString>& jLineString) {
static auto& javaClass = jni::Class<LineString>::Singleton(env);
static auto method = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
static auto method = javaClass.GetMethod<jni::Object<java::util::List>()>(env, "coordinates");
return jLineString.Call(env, method);
}
void LineString::registerNative(jni::JNIEnv &env) {
void LineString::registerNative(jni::JNIEnv& env) {
jni::Class<LineString>::Singleton(env);
}

3
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/line_string.hpp
View File

@@ -13,7 +13,6 @@ namespace mbgl {
namespace android {
namespace geojson {
class LineString {
public:
using SuperTag = Geometry;
@@ -24,7 +23,7 @@ public:
static mapbox::geojson::line_string convert(jni::JNIEnv&, const jni::Object<LineString>&);
static mapbox::geojson::line_string convert(jni::JNIEnv&, const jni::Object<java::util::List/*<Point>*/>&);
static mapbox::geojson::line_string convert(jni::JNIEnv&, const jni::Object<java::util::List /*<Point>*/>&);
static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv&, const jni::Object<LineString>&);

19
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/multi_line_string.cpp
View File

@@ -7,14 +7,17 @@ namespace mbgl {
namespace android {
namespace geojson {
jni::Local<jni::Object<MultiLineString>> MultiLineString::New(jni::JNIEnv& env, const mbgl::MultiLineString<double>& multiLineString) {
jni::Local<jni::Object<MultiLineString>> MultiLineString::New(jni::JNIEnv& env,
const mbgl::MultiLineString<double>& multiLineString) {
static auto& javaClass = jni::Class<MultiLineString>::Singleton(env);
static auto method = javaClass.GetStaticMethod<jni::Object<MultiLineString> (jni::Object<java::util::List>)>(env, "fromLngLats");
static auto method = javaClass.GetStaticMethod<jni::Object<MultiLineString>(jni::Object<java::util::List>)>(
env, "fromLngLats");
return javaClass.Call(env, method, asPointsListsList(env, multiLineString));
}
mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv &env, const jni::Object<MultiLineString>& jMultiLineString) {
mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv& env,
const jni::Object<MultiLineString>& jMultiLineString) {
mapbox::geojson::multi_line_string multiLineString;
if (jMultiLineString) {
@@ -24,7 +27,8 @@ mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv &env, co
return multiLineString;
}
mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv &env, const jni::Object<java::util::List/*<java::util::List<Point>>*/>& jPointListsList) {
mapbox::geojson::multi_line_string MultiLineString::convert(
jni::JNIEnv& env, const jni::Object<java::util::List /*<java::util::List<Point>>*/>& jPointListsList) {
mapbox::geojson::multi_line_string multiLineString;
if (jPointListsList) {
@@ -41,13 +45,14 @@ mapbox::geojson::multi_line_string MultiLineString::convert(jni::JNIEnv &env, co
return multiLineString;
}
jni::Local<jni::Object<java::util::List>> MultiLineString::coordinates(jni::JNIEnv &env, const jni::Object<MultiLineString>& jLineString) {
jni::Local<jni::Object<java::util::List>> MultiLineString::coordinates(
jni::JNIEnv& env, const jni::Object<MultiLineString>& jLineString) {
static auto& javaClass = jni::Class<MultiLineString>::Singleton(env);
static auto method = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
static auto method = javaClass.GetMethod<jni::Object<java::util::List>()>(env, "coordinates");
return jLineString.Call(env, method);
}
void MultiLineString::registerNative(jni::JNIEnv &env) {
void MultiLineString::registerNative(jni::JNIEnv& env) {
jni::Class<MultiLineString>::Singleton(env);
}

3
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/multi_line_string.hpp
View File

@@ -22,7 +22,8 @@ public:
static mapbox::geojson::multi_line_string convert(jni::JNIEnv&, const jni::Object<MultiLineString>&);
static mapbox::geojson::multi_line_string convert(jni::JNIEnv&, const jni::Object<java::util::List/*<java::util::List<Point>>*/>&);
static mapbox::geojson::multi_line_string convert(
jni::JNIEnv&, const jni::Object<java::util::List /*<java::util::List<Point>>*/>&);
static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv&, const jni::Object<MultiLineString>&);

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

@@ -10,7 +10,8 @@ namespace geojson {
jni::Local<jni::Object<MultiPoint>> MultiPoint::New(JNIEnv& env, const mbgl::MultiPoint<double>& multiPoint) {
static auto& javaClass = jni::Class<MultiPoint>::Singleton(env);
static auto method = javaClass.GetStaticMethod<jni::Object<MultiPoint>(jni::Object<java::util::List>)>(env, "fromLngLats");
static auto method = javaClass.GetStaticMethod<jni::Object<MultiPoint>(jni::Object<java::util::List>)>(
env, "fromLngLats");
return javaClass.Call(env, method, asPointsList(env, multiPoint));
}
@@ -26,13 +27,14 @@ mapbox::geojson::multi_point MultiPoint::convert(jni::JNIEnv& env, const jni::Ob
return multiPoint;
}
jni::Local<jni::Object<java::util::List>> MultiPoint::coordinates(jni::JNIEnv& env, const jni::Object<MultiPoint>& jMultiPoint) {
jni::Local<jni::Object<java::util::List>> MultiPoint::coordinates(jni::JNIEnv& env,
const jni::Object<MultiPoint>& jMultiPoint) {
static auto& javaClass = jni::Class<MultiPoint>::Singleton(env);
static auto method = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
static auto method = javaClass.GetMethod<jni::Object<java::util::List>()>(env, "coordinates");
return jMultiPoint.Call(env, method);
}
void MultiPoint::registerNative(jni::JNIEnv &env) {
void MultiPoint::registerNative(jni::JNIEnv& env) {
jni::Class<MultiPoint>::Singleton(env);
}

10
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/multi_polygon.cpp
View File

@@ -9,7 +9,8 @@ namespace geojson {
jni::Local<jni::Object<MultiPolygon>> MultiPolygon::New(JNIEnv& env, const mbgl::MultiPolygon<double>& multiPolygon) {
static auto& javaClass = jni::Class<MultiPolygon>::Singleton(env);
static auto method = javaClass.GetStaticMethod<jni::Object<MultiPolygon> (jni::Object<java::util::List>)>(env, "fromLngLats");
static auto method = javaClass.GetStaticMethod<jni::Object<MultiPolygon>(jni::Object<java::util::List>)>(
env, "fromLngLats");
auto jarray = jni::Array<jni::Object<java::util::List>>::New(env, multiPolygon.size());
@@ -38,13 +39,14 @@ mapbox::geojson::multi_polygon MultiPolygon::convert(jni::JNIEnv& env, const jni
return multiPolygon;
}
jni::Local<jni::Object<java::util::List>> MultiPolygon::coordinates(jni::JNIEnv& env, const jni::Object<MultiPolygon>& jPolygon) {
jni::Local<jni::Object<java::util::List>> MultiPolygon::coordinates(jni::JNIEnv& env,
const jni::Object<MultiPolygon>& jPolygon) {
static auto& javaClass = jni::Class<MultiPolygon>::Singleton(env);
static auto method = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
static auto method = javaClass.GetMethod<jni::Object<java::util::List>()>(env, "coordinates");
return jPolygon.Call(env, method);
}
void MultiPolygon::registerNative(jni::JNIEnv &env) {
void MultiPolygon::registerNative(jni::JNIEnv& env) {
jni::Class<MultiPolygon>::Singleton(env);
}

15
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/point.cpp
View File

@@ -6,26 +6,23 @@ namespace geojson {
jni::Local<jni::Object<Point>> Point::New(jni::JNIEnv& env, const mbgl::Point<double>& point) {
static auto& javaClass = jni::Class<Point>::Singleton(env);
static auto method = javaClass.GetStaticMethod<jni::Object<Point> (jni::jdouble, jni::jdouble)>(env, "fromLngLat");
static auto method = javaClass.GetStaticMethod<jni::Object<Point>(jni::jdouble, jni::jdouble)>(env, "fromLngLat");
return javaClass.Call(env, method, point.x, point.y);
}
mbgl::Point<double> Point::convert(jni::JNIEnv &env, const jni::Object<Point>& jPoint) {
mbgl::Point<double> Point::convert(jni::JNIEnv& env, const jni::Object<Point>& jPoint) {
static auto& javaClass = jni::Class<Point>::Singleton(env);
static auto longitude = javaClass.GetMethod<jni::jdouble ()>(env, "longitude");
static auto latitude = javaClass.GetMethod<jni::jdouble ()>(env, "latitude");
static auto longitude = javaClass.GetMethod<jni::jdouble()>(env, "longitude");
static auto latitude = javaClass.GetMethod<jni::jdouble()>(env, "latitude");
if (!jPoint) {
return {};
}
return {
jPoint.Call(env, longitude),
jPoint.Call(env, latitude)
};
return {jPoint.Call(env, longitude), jPoint.Call(env, latitude)};
}
void Point::registerNative(jni::JNIEnv &env) {
void Point::registerNative(jni::JNIEnv& env) {
jni::Class<Point>::Singleton(env);
}

15
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/polygon.cpp
View File

@@ -10,12 +10,13 @@ namespace geojson {
jni::Local<jni::Object<Polygon>> Polygon::New(jni::JNIEnv& env, const mbgl::Polygon<double>& polygon) {
static auto& javaClass = jni::Class<Polygon>::Singleton(env);
static auto method = javaClass.GetStaticMethod<jni::Object<Polygon> (jni::Object<java::util::List>)>(env, "fromLngLats");
static auto method = javaClass.GetStaticMethod<jni::Object<Polygon>(jni::Object<java::util::List>)>(env,
"fromLngLats");
return javaClass.Call(env, method, asPointsListsList(env, polygon));
}
mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, const jni::Object<Polygon>& jPolygon) {
mapbox::geojson::polygon Polygon::convert(jni::JNIEnv& env, const jni::Object<Polygon>& jPolygon) {
mapbox::geojson::polygon polygon;
if (jPolygon) {
@@ -25,7 +26,8 @@ mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, const jni::Object<Po
return polygon;
}
mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, const jni::Object<java::util::List/*<java::util::List<Point>>*/>& jPointListsList) {
mapbox::geojson::polygon Polygon::convert(
jni::JNIEnv& env, const jni::Object<java::util::List /*<java::util::List<Point>>*/>& jPointListsList) {
mapbox::geojson::polygon polygon;
if (jPointListsList) {
@@ -39,14 +41,13 @@ mapbox::geojson::polygon Polygon::convert(jni::JNIEnv &env, const jni::Object<ja
return polygon;
}
jni::Local<jni::Object<java::util::List>> Polygon::coordinates(jni::JNIEnv &env, const jni::Object<Polygon>& jPolygon) {
jni::Local<jni::Object<java::util::List>> Polygon::coordinates(jni::JNIEnv& env, const jni::Object<Polygon>& jPolygon) {
static auto& javaClass = jni::Class<Polygon>::Singleton(env);
static auto method = javaClass.GetMethod<jni::Object<java::util::List> ()>(env, "coordinates");
static auto method = javaClass.GetMethod<jni::Object<java::util::List>()>(env, "coordinates");
return jPolygon.Call(env, method);
}
void Polygon::registerNative(jni::JNIEnv &env) {
void Polygon::registerNative(jni::JNIEnv& env) {
jni::Class<Polygon>::Singleton(env);
}

10
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/polygon.hpp
View File

@@ -8,7 +8,6 @@
#include <jni/jni.hpp>
namespace mbgl {
namespace android {
namespace geojson {
@@ -19,13 +18,14 @@ public:
static constexpr auto Name() { return "com/mapbox/geojson/Polygon"; };
static constexpr auto Type() { return "Polygon"; };
static jni::Local<jni::Object<Polygon>> New(jni::JNIEnv&, const mbgl::Polygon<double>&);
static jni::Local<jni::Object<Polygon>> New(jni::JNIEnv &, const mbgl::Polygon<double> &);
static mapbox::geojson::polygon convert(jni::JNIEnv &, const jni::Object<Polygon>&);
static mapbox::geojson::polygon convert(jni::JNIEnv &, const jni::Object<Polygon> &);
static mapbox::geojson::polygon convert(jni::JNIEnv&, const jni::Object<java::util::List/*<java::util::List<Point>>*/>&);
static mapbox::geojson::polygon convert(jni::JNIEnv &,
const jni::Object<java::util::List /*<java::util::List<Point>>*/> &);
static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv&, const jni::Object<Polygon>&);
static jni::Local<jni::Object<java::util::List>> coordinates(jni::JNIEnv &, const jni::Object<Polygon> &);
static void registerNative(jni::JNIEnv &);
};

6
platform/android/MapboxGLAndroidSDK/src/cpp/geojson/util.hpp
View File

@@ -11,11 +11,9 @@ namespace geojson {
// Clang 3.8 fails to implicitly convert matching types, so we'll have to do it explicitly.
template <typename To, typename From>
To convertExplicit(From&& src) {
static_assert(std::is_same<typename std::decay_t<From>::container_type,
typename To::container_type>::value,
static_assert(std::is_same<typename std::decay_t<From>::container_type, typename To::container_type>::value,
"container types do not match");
static_assert(std::is_rvalue_reference<From&&>::value,
"argument must be rvalue reference");
static_assert(std::is_rvalue_reference<From&&>::value, "argument must be rvalue reference");
return *reinterpret_cast<std::add_pointer_t<To>>(&src);
}

3
platform/android/MapboxGLAndroidSDK/src/cpp/geometry/lat_lng.hpp
View File

@@ -11,7 +11,6 @@ namespace android {
class LatLng : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/geometry/LatLng"; };
static jni::Local<jni::Object<LatLng>> New(jni::JNIEnv&, const mbgl::LatLng&);
@@ -20,10 +19,8 @@ public:
static mbgl::LatLng getLatLng(jni::JNIEnv&, const jni::Object<LatLng>&);
static void registerNative(jni::JNIEnv&);
};
} // namespace android
} // namespace mbgl

4
platform/android/MapboxGLAndroidSDK/src/cpp/geometry/lat_lng_bounds.cpp
View File

@@ -16,8 +16,8 @@ mbgl::LatLngBounds LatLngBounds::getLatLngBounds(jni::JNIEnv& env, const jni::Ob
static auto neLatField = javaClass.GetField<jni::jdouble>(env, "latitudeNorth");
static auto neLonField = javaClass.GetField<jni::jdouble>(env, "longitudeEast");
mbgl::LatLng sw = { bounds.Get(env, swLatField), bounds.Get(env, swLonField) };
mbgl::LatLng ne = { bounds.Get(env, neLatField), bounds.Get(env, neLonField) };
mbgl::LatLng sw = {bounds.Get(env, swLatField), bounds.Get(env, swLonField)};
mbgl::LatLng ne = {bounds.Get(env, neLatField), bounds.Get(env, neLonField)};
return mbgl::LatLngBounds::hull(sw, ne);
}

2
platform/android/MapboxGLAndroidSDK/src/cpp/geometry/lat_lng_bounds.hpp
View File

@@ -11,7 +11,6 @@ namespace android {
class LatLngBounds : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/geometry/LatLngBounds"; };
static jni::Local<jni::Object<LatLngBounds>> New(jni::JNIEnv&, mbgl::LatLngBounds);
@@ -21,6 +20,5 @@ public:
static void registerNative(jni::JNIEnv&);
};
} // namespace android
} // namespace mbgl

33
platform/android/MapboxGLAndroidSDK/src/cpp/geometry/lat_lng_quad.cpp
View File

@@ -6,27 +6,28 @@ namespace android {
jni::Local<jni::Object<LatLngQuad>> LatLngQuad::New(jni::JNIEnv& env, std::array<mbgl::LatLng, 4> coordinates) {
static auto& javaClass = jni::Class<LatLngQuad>::Singleton(env);
static auto quadConstructor = javaClass.GetConstructor<jni::Object<LatLng>, jni::Object<LatLng>, jni::Object<LatLng>, jni::Object<LatLng>>(env);
return javaClass.New(env, quadConstructor,
LatLng::New(env, coordinates[0]),
LatLng::New(env, coordinates[1]),
LatLng::New(env, coordinates[2]),
LatLng::New(env, coordinates[3]));
static auto quadConstructor =
javaClass.GetConstructor<jni::Object<LatLng>, jni::Object<LatLng>, jni::Object<LatLng>, jni::Object<LatLng>>(
env);
return javaClass.New(env,
quadConstructor,
LatLng::New(env, coordinates[0]),
LatLng::New(env, coordinates[1]),
LatLng::New(env, coordinates[2]),
LatLng::New(env, coordinates[3]));
}
std::array<mbgl::LatLng, 4> LatLngQuad::getLatLngArray(jni::JNIEnv& env, const jni::Object<LatLngQuad>& quad) {
static auto& javaClass = jni::Class<LatLngQuad>::Singleton(env);
static auto topLeftField = javaClass.GetField <jni::Object<LatLng>>(env, "topLeft");
static auto topRightField = javaClass.GetField <jni::Object<LatLng>>(env, "topRight");
static auto bottomRightField = javaClass.GetField <jni::Object<LatLng>>(env, "bottomRight");
static auto bottomLeftField = javaClass.GetField <jni::Object<LatLng>>(env, "bottomLeft");
static auto topLeftField = javaClass.GetField<jni::Object<LatLng>>(env, "topLeft");
static auto topRightField = javaClass.GetField<jni::Object<LatLng>>(env, "topRight");
static auto bottomRightField = javaClass.GetField<jni::Object<LatLng>>(env, "bottomRight");
static auto bottomLeftField = javaClass.GetField<jni::Object<LatLng>>(env, "bottomLeft");
return std::array < mbgl::LatLng, 4 > {{
LatLng::getLatLng(env, quad.Get(env, topLeftField)),
LatLng::getLatLng(env, quad.Get(env, topRightField)),
LatLng::getLatLng(env, quad.Get(env, bottomRightField)),
LatLng::getLatLng(env, quad.Get(env, bottomLeftField))
}};
return std::array<mbgl::LatLng, 4>{{LatLng::getLatLng(env, quad.Get(env, topLeftField)),
LatLng::getLatLng(env, quad.Get(env, topRightField)),
LatLng::getLatLng(env, quad.Get(env, bottomRightField)),
LatLng::getLatLng(env, quad.Get(env, bottomLeftField))}};
}
void LatLngQuad::registerNative(jni::JNIEnv& env) {

2
platform/android/MapboxGLAndroidSDK/src/cpp/geometry/lat_lng_quad.hpp
View File

@@ -12,7 +12,6 @@ namespace android {
class LatLngQuad : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/geometry/LatLngQuad"; };
static jni::Local<jni::Object<LatLngQuad>> New(jni::JNIEnv&, std::array<mbgl::LatLng, 4>);
@@ -22,6 +21,5 @@ public:
static void registerNative(jni::JNIEnv&);
};
} // namespace android
} // namespace mbgl

2
platform/android/MapboxGLAndroidSDK/src/cpp/graphics/pointf.hpp
View File

@@ -9,7 +9,6 @@ namespace android {
class PointF : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "android/graphics/PointF"; };
static jni::Local<jni::Object<PointF>> New(jni::JNIEnv&, float, float);
@@ -19,6 +18,5 @@ public:
static void registerNative(jni::JNIEnv&);
};
} // namespace android
} // namespace mbgl

2
platform/android/MapboxGLAndroidSDK/src/cpp/graphics/rectf.hpp
View File

@@ -9,7 +9,6 @@ namespace android {
class RectF : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "android/graphics/RectF"; };
static float getLeft(jni::JNIEnv&, const jni::Object<RectF>&);
@@ -23,6 +22,5 @@ public:
static void registerNative(jni::JNIEnv&);
};
} // namespace android
} // namespace mbgl

10
platform/android/MapboxGLAndroidSDK/src/cpp/gson/json_array.cpp
View File

@@ -5,14 +5,14 @@ namespace mbgl {
namespace android {
namespace gson {
jni::Local<jni::Object<JsonArray>> JsonArray::New(jni::JNIEnv& env, const std::vector<mbgl::Value>& values){
jni::Local<jni::Object<JsonArray>> JsonArray::New(jni::JNIEnv& env, const std::vector<mbgl::Value>& values) {
static auto& javaClass = jni::Class<JsonArray>::Singleton(env);
static auto constructor = javaClass.GetConstructor(env);
static auto addMethod = javaClass.GetMethod<void (jni::Object<JsonElement>)>(env, "add");
static auto addMethod = javaClass.GetMethod<void(jni::Object<JsonElement>)>(env, "add");
auto jsonArray = javaClass.New(env, constructor);
for (const auto &v : values) {
for (const auto& v : values) {
jsonArray.Call(env, addMethod, JsonElement::New(env, v));
}
@@ -24,8 +24,8 @@ std::vector<mbgl::Value> JsonArray::convert(jni::JNIEnv& env, const jni::Object<
if (jsonArray) {
static auto& javaClass = jni::Class<JsonArray>::Singleton(env);
static auto getMethod = javaClass.GetMethod<jni::Object<JsonElement> (jni::jint)>(env, "get");
static auto sizeMethod = javaClass.GetMethod<jni::jint ()>(env, "size");
static auto getMethod = javaClass.GetMethod<jni::Object<JsonElement>(jni::jint)>(env, "get");
static auto sizeMethod = javaClass.GetMethod<jni::jint()>(env, "size");
int size = jsonArray.Call(env, sizeMethod);
values.reserve(uint(size));

49
platform/android/MapboxGLAndroidSDK/src/cpp/gson/json_element.cpp
View File

@@ -14,50 +14,39 @@ jni::Local<jni::Object<JsonElement>> JsonElement::New(jni::JNIEnv& env, const mb
static auto booleanConstructor = primitive.GetConstructor<jni::Boolean>(env);
return value.match(
[&] (const mbgl::NullValue&) {
return jni::Local<jni::Object<JsonElement>>();
},
[&] (const std::string& value) {
[&](const mbgl::NullValue&) { return jni::Local<jni::Object<JsonElement>>(); },
[&](const std::string& value) {
return primitive.New(env, stringConstructor, jni::Make<jni::String>(env, value));
},
[&] (const double value) {
return primitive.New(env, numberConstructor, jni::Box(env, value));
},
[&] (const int64_t value) {
return primitive.New(env, numberConstructor, jni::Box(env, value));
},
[&] (const uint64_t value) {
[&](const double value) { return primitive.New(env, numberConstructor, jni::Box(env, value)); },
[&](const int64_t value) { return primitive.New(env, numberConstructor, jni::Box(env, value)); },
[&](const uint64_t value) {
return primitive.New(env, numberConstructor, jni::Box(env, int64_t(value))); // TODO: should use BigInteger
},
[&] (const bool value) {
[&](const bool value) {
return primitive.New(env, booleanConstructor, jni::Box(env, value ? jni::jni_true : jni::jni_false));
},
[&] (const std::vector<mbgl::Value>& values) {
return JsonArray::New(env, values);
},
[&] (const mbgl::PropertyMap& values) {
return JsonObject::New(env, values);
}
);
[&](const std::vector<mbgl::Value>& values) { return JsonArray::New(env, values); },
[&](const mbgl::PropertyMap& values) { return JsonObject::New(env, values); });
}
mbgl::Value JsonElement::convert(jni::JNIEnv &env, const jni::Object<JsonElement>& jsonElement) {
mbgl::Value JsonElement::convert(jni::JNIEnv& env, const jni::Object<JsonElement>& jsonElement) {
if (!jsonElement) {
return mbgl::NullValue();
}
static auto& elementClass = jni::Class<JsonElement>::Singleton(env);
static auto isJsonObject = elementClass.GetMethod<jni::jboolean ()>(env, "isJsonObject");
static auto isJsonArray = elementClass.GetMethod<jni::jboolean ()>(env, "isJsonArray");
static auto isJsonPrimitive = elementClass.GetMethod<jni::jboolean ()>(env, "isJsonPrimitive");
static auto isJsonObject = elementClass.GetMethod<jni::jboolean()>(env, "isJsonObject");
static auto isJsonArray = elementClass.GetMethod<jni::jboolean()>(env, "isJsonArray");
static auto isJsonPrimitive = elementClass.GetMethod<jni::jboolean()>(env, "isJsonPrimitive");
static auto& primitiveClass = jni::Class<JsonPrimitive>::Singleton(env);
static auto isBoolean = primitiveClass.GetMethod<jni::jboolean ()>(env, "isBoolean");
static auto isString = primitiveClass.GetMethod<jni::jboolean ()>(env, "isString");
static auto isNumber = primitiveClass.GetMethod<jni::jboolean ()>(env, "isNumber");
static auto getAsBoolean = primitiveClass.GetMethod<jni::jboolean ()>(env, "getAsBoolean");
static auto getAsString = primitiveClass.GetMethod<jni::String ()>(env, "getAsString");
static auto getAsDouble = primitiveClass.GetMethod<jni::jdouble ()>(env, "getAsDouble");
static auto isBoolean = primitiveClass.GetMethod<jni::jboolean()>(env, "isBoolean");
static auto isString = primitiveClass.GetMethod<jni::jboolean()>(env, "isString");
static auto isNumber = primitiveClass.GetMethod<jni::jboolean()>(env, "isNumber");
static auto getAsBoolean = primitiveClass.GetMethod<jni::jboolean()>(env, "getAsBoolean");
static auto getAsString = primitiveClass.GetMethod<jni::String()>(env, "getAsString");
static auto getAsDouble = primitiveClass.GetMethod<jni::jdouble()>(env, "getAsDouble");
if (jsonElement.Call(env, isJsonPrimitive)) {
auto primitive = jni::Cast(env, primitiveClass, jsonElement);
@@ -79,7 +68,7 @@ mbgl::Value JsonElement::convert(jni::JNIEnv &env, const jni::Object<JsonElement
}
}
void JsonElement::registerNative(jni::JNIEnv &env) {
void JsonElement::registerNative(jni::JNIEnv& env) {
jni::Class<JsonElement>::Singleton(env);
}

25
platform/android/MapboxGLAndroidSDK/src/cpp/gson/json_object.cpp
View File

@@ -8,18 +8,15 @@ namespace mbgl {
namespace android {
namespace gson {
jni::Local<jni::Object<JsonObject>> JsonObject::New(jni::JNIEnv& env, const mbgl::PropertyMap& values) {
static auto& javaClass = jni::Class<JsonObject>::Singleton(env);
static auto constructor = javaClass.GetConstructor(env);
static auto addMethod = javaClass.GetMethod<void (jni::String, jni::Object<JsonElement>)>(env, "add");
static auto addMethod = javaClass.GetMethod<void(jni::String, jni::Object<JsonElement>)>(env, "add");
auto jsonObject = javaClass.New(env, constructor);
for (auto &item : values) {
jsonObject.Call(env, addMethod,
jni::Make<jni::String>(env, item.first),
JsonElement::New(env, item.second));
for (auto& item : values) {
jsonObject.Call(env, addMethod, jni::Make<jni::String>(env, item.first), JsonElement::New(env, item.second));
}
return jsonObject;
@@ -29,7 +26,7 @@ template <typename F> // void (jni::String, jni::Object<gson::JsonElement>)
static void iterateEntrySet(jni::JNIEnv& env, const jni::Object<JsonObject>& jsonObject, F callback) {
// Get Set<Map.Entry<String, JsonElement>>
static auto& javaClass = jni::Class<JsonObject>::Singleton(env);
static auto method = javaClass.GetMethod<jni::Object<java::util::Set> ()>(env, "entrySet");
static auto method = javaClass.GetMethod<jni::Object<java::util::Set>()>(env, "entrySet");
auto entryArray = java::util::Set::toArray<java::util::Map::Entry>(env, jsonObject.Call(env, method));
@@ -37,9 +34,8 @@ static void iterateEntrySet(jni::JNIEnv& env, const jni::Object<JsonObject>& jso
for (size_t i = 0; i < size; i++) {
auto entry = entryArray.Get(env, i);
if (entry) {
callback(
java::util::Map::Entry::getKey<jni::StringTag>(env, entry),
java::util::Map::Entry::getValue<gson::JsonElement>(env, entry));
callback(java::util::Map::Entry::getKey<jni::StringTag>(env, entry),
java::util::Map::Entry::getValue<gson::JsonElement>(env, entry));
}
}
}
@@ -48,15 +44,16 @@ mbgl::PropertyMap JsonObject::convert(jni::JNIEnv& env, const jni::Object<JsonOb
mbgl::PropertyMap map;
if (jsonObject) {
iterateEntrySet(env, jsonObject, [&map, &env](const jni::String& jId, const jni::Object<gson::JsonElement>& jsonElement) {
map[jni::Make<std::string>(env, jId)] = JsonElement::convert(env, jsonElement);
});
iterateEntrySet(
env, jsonObject, [&map, &env](const jni::String& jId, const jni::Object<gson::JsonElement>& jsonElement) {
map[jni::Make<std::string>(env, jId)] = JsonElement::convert(env, jsonElement);
});
}
return map;
}
void JsonObject::registerNative(jni::JNIEnv &env) {
void JsonObject::registerNative(jni::JNIEnv& env) {
jni::Class<JsonObject>::Singleton(env);
}

81
platform/android/MapboxGLAndroidSDK/src/cpp/http_file_source.cpp
View File

@@ -19,15 +19,16 @@ namespace mbgl {
class HTTPFileSource::Impl {
public:
Impl(const ResourceOptions resourceOptions_, const ClientOptions clientOptions_)
: resourceOptions(resourceOptions_.clone()), clientOptions(clientOptions_.clone()) {};
: resourceOptions(resourceOptions_.clone()),
clientOptions(clientOptions_.clone()){};
android::UniqueEnv env { android::AttachEnv() };
android::UniqueEnv env{android::AttachEnv()};
void setResourceOptions(ResourceOptions options) {resourceOptions = options;};
ResourceOptions getResourceOptions() {return resourceOptions.clone(); };
void setResourceOptions(ResourceOptions options) { resourceOptions = options; };
ResourceOptions getResourceOptions() { return resourceOptions.clone(); };
void setClientOptions(ClientOptions options) {clientOptions = options;};
ClientOptions getClientOptions() {return clientOptions.clone();};
void setClientOptions(ClientOptions options) { clientOptions = options; };
ClientOptions getClientOptions() { return clientOptions.clone(); };
private:
ResourceOptions resourceOptions;
@@ -42,10 +43,14 @@ public:
~HTTPRequest();
void onFailure(jni::JNIEnv&, int type, const jni::String& message);
void onResponse(jni::JNIEnv&, int code,
const jni::String& etag, const jni::String& modified,
const jni::String& cacheControl, const jni::String& expires,
const jni::String& retryAfter, const jni::String& xRateLimitReset,
void onResponse(jni::JNIEnv&,
int code,
const jni::String& etag,
const jni::String& modified,
const jni::String& cacheControl,
const jni::String& expires,
const jni::String& retryAfter,
const jni::String& xRateLimitReset,
const jni::Array<jni::jbyte>& body);
jni::Global<jni::Object<HTTPRequest>> javaRequest;
@@ -55,12 +60,12 @@ private:
FileSource::Callback callback;
Response response;
util::AsyncTask async { [this] {
util::AsyncTask async{[this] {
// Calling `callback` may result in deleting `this`. Copy data to temporaries first.
auto callback_ = callback;
auto response_ = response;
callback_(response_);
} };
}};
static const int connectionError = 0;
static const int temporaryError = 1;
@@ -72,11 +77,13 @@ namespace android {
void RegisterNativeHTTPRequest(jni::JNIEnv& env) {
static auto& javaClass = jni::Class<HTTPRequest>::Singleton(env);
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
jni::RegisterNativePeer<HTTPRequest>(env, javaClass, "nativePtr",
METHOD(&HTTPRequest::onFailure, "nativeOnFailure"),
METHOD(&HTTPRequest::onResponse, "nativeOnResponse"));
jni::RegisterNativePeer<HTTPRequest>(env,
javaClass,
"nativePtr",
METHOD(&HTTPRequest::onFailure, "nativeOnFailure"),
METHOD(&HTTPRequest::onResponse, "nativeOnResponse"));
}
} // namespace android
@@ -100,31 +107,33 @@ HTTPRequest::HTTPRequest(jni::JNIEnv& env, const Resource& resource_, FileSource
javaClass.GetConstructor<jni::jlong, jni::String, jni::String, jni::String, jni::jboolean>(env);
javaRequest = jni::NewGlobal(env,
javaClass.New(env, constructor,
reinterpret_cast<jlong>(this),
jni::Make<jni::String>(env, resource.url),
jni::Make<jni::String>(env, etagStr),
jni::Make<jni::String>(env, modifiedStr),
(jboolean) (resource_.usage == Resource::Usage::Offline)
)
);
javaClass.New(env,
constructor,
reinterpret_cast<jlong>(this),
jni::Make<jni::String>(env, resource.url),
jni::Make<jni::String>(env, etagStr),
jni::Make<jni::String>(env, modifiedStr),
(jboolean)(resource_.usage == Resource::Usage::Offline)));
}
HTTPRequest::~HTTPRequest() {
android::UniqueEnv env = android::AttachEnv();
static auto& javaClass = jni::Class<HTTPRequest>::Singleton(*env);
static auto cancel = javaClass.GetMethod<void ()>(*env, "cancel");
static auto cancel = javaClass.GetMethod<void()>(*env, "cancel");
javaRequest.Call(*env, cancel);
}
void HTTPRequest::onResponse(jni::JNIEnv& env, int code,
const jni::String& etag, const jni::String& modified,
const jni::String& cacheControl, const jni::String& expires,
const jni::String& jRetryAfter, const jni::String& jXRateLimitReset,
void HTTPRequest::onResponse(jni::JNIEnv& env,
int code,
const jni::String& etag,
const jni::String& modified,
const jni::String& cacheControl,
const jni::String& expires,
const jni::String& jRetryAfter,
const jni::String& jXRateLimitReset,
const jni::Array<jni::jbyte>& body) {
using Error = Response::Error;
if (etag) {
@@ -168,11 +177,14 @@ void HTTPRequest::onResponse(jni::JNIEnv& env, int code,
if (jXRateLimitReset) {
xRateLimitReset = jni::Make<std::string>(env, jXRateLimitReset);
}
response.error = std::make_unique<Error>(Error::Reason::RateLimit, "HTTP status code 429", http::parseRetryHeaders(retryAfter, xRateLimitReset));
response.error = std::make_unique<Error>(
Error::Reason::RateLimit, "HTTP status code 429", http::parseRetryHeaders(retryAfter, xRateLimitReset));
} else if (code >= 500 && code < 600) {
response.error = std::make_unique<Error>(Error::Reason::Server, std::string{ "HTTP status code " } + util::toString(code));
response.error = std::make_unique<Error>(Error::Reason::Server,
std::string{"HTTP status code "} + util::toString(code));
} else {
response.error = std::make_unique<Error>(Error::Reason::Other, std::string{ "HTTP status code " } + util::toString(code));
response.error = std::make_unique<Error>(Error::Reason::Other,
std::string{"HTTP status code "} + util::toString(code));
}
async.send();
@@ -198,8 +210,7 @@ void HTTPRequest::onFailure(jni::JNIEnv& env, int type, const jni::String& messa
}
HTTPFileSource::HTTPFileSource(const ResourceOptions& resourceOptions, const ClientOptions& clientOptions)
: impl(std::make_unique<Impl>(resourceOptions.clone(), clientOptions.clone())) {
}
: impl(std::make_unique<Impl>(resourceOptions.clone(), clientOptions.clone())) {}
HTTPFileSource::~HTTPFileSource() = default;

59
platform/android/MapboxGLAndroidSDK/src/cpp/i18n/collator.cpp
View File

@@ -15,19 +15,22 @@ void Collator::registerNative(jni::JNIEnv& env) {
jni::Local<jni::Object<Collator>> Collator::getInstance(jni::JNIEnv& env, const jni::Object<Locale>& locale) {
static auto& javaClass = jni::Class<Collator>::Singleton(env);
static auto method = javaClass.GetStaticMethod<jni::Object<Collator> (jni::Object<Locale>)>(env, "getInstance");
static auto method = javaClass.GetStaticMethod<jni::Object<Collator>(jni::Object<Locale>)>(env, "getInstance");
return javaClass.Call(env, method, locale);
}
void Collator::setStrength(jni::JNIEnv& env, const jni::Object<Collator>& collator, jni::jint strength) {
static auto& javaClass = jni::Class<Collator>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::jint)>(env, "setStrength");
static auto method = javaClass.GetMethod<void(jni::jint)>(env, "setStrength");
collator.Call(env, method, strength);
}
jni::jint Collator::compare(jni::JNIEnv& env, const jni::Object<Collator>& collator, const jni::String& lhs, const jni::String& rhs) {
jni::jint Collator::compare(jni::JNIEnv& env,
const jni::Object<Collator>& collator,
const jni::String& lhs,
const jni::String& rhs) {
static auto& javaClass = jni::Class<Collator>::Singleton(env);
static auto method = javaClass.GetMethod<jni::jint (jni::String, jni::String)>(env, "compare");
static auto method = javaClass.GetMethod<jni::jint(jni::String, jni::String)>(env, "compare");
return collator.Call(env, method, lhs, rhs);
}
@@ -37,7 +40,7 @@ void StringUtils::registerNative(jni::JNIEnv& env) {
jni::Local<jni::String> StringUtils::unaccent(jni::JNIEnv& env, const jni::String& value) {
static auto& javaClass = jni::Class<StringUtils>::Singleton(env);
static auto method = javaClass.GetStaticMethod<jni::String (jni::String)>(env, "unaccent");
static auto method = javaClass.GetStaticMethod<jni::String(jni::String)>(env, "unaccent");
return javaClass.Call(env, method, value);
}
@@ -63,19 +66,19 @@ jni::String Locale::toLanguageTag(jni::JNIEnv& env, jni::Object<Locale> locale)
jni::Local<jni::String> Locale::getLanguage(jni::JNIEnv& env, const jni::Object<Locale>& locale) {
static auto& javaClass = jni::Class<Locale>::Singleton(env);
static auto method = javaClass.GetMethod<jni::String ()>(env, "getLanguage");
static auto method = javaClass.GetMethod<jni::String()>(env, "getLanguage");
return locale.Call(env, method);
}
jni::Local<jni::String> Locale::getCountry(jni::JNIEnv& env, const jni::Object<Locale>& locale) {
static auto& javaClass = jni::Class<Locale>::Singleton(env);
static auto method = javaClass.GetMethod<jni::String ()>(env, "getCountry");
static auto method = javaClass.GetMethod<jni::String()>(env, "getCountry");
return locale.Call(env, method);
}
jni::Local<jni::Object<Locale>> Locale::getDefault(jni::JNIEnv& env) {
static auto& javaClass = jni::Class<Locale>::Singleton(env);
static auto method = javaClass.GetStaticMethod<jni::Object<Locale> ()>(env, "getDefault");
static auto method = javaClass.GetStaticMethod<jni::Object<Locale>()>(env, "getDefault");
return javaClass.Call(env, method);
}
@@ -98,21 +101,20 @@ namespace platform {
class Collator::Impl {
public:
Impl(bool caseSensitive_, bool diacriticSensitive_, std::optional<std::string> locale_)
: caseSensitive(caseSensitive_)
, diacriticSensitive(diacriticSensitive_)
, env(android::AttachEnv())
{
: caseSensitive(caseSensitive_),
diacriticSensitive(diacriticSensitive_),
env(android::AttachEnv()) {
LanguageTag languageTag = locale_ ? LanguageTag::fromBCP47(*locale_) : LanguageTag();
if (!languageTag.language) {
locale = jni::NewGlobal(*env,
android::Locale::getDefault(*env));
locale = jni::NewGlobal(*env, android::Locale::getDefault(*env));
} else if (!languageTag.region) {
locale = jni::NewGlobal(*env,
android::Locale::New(*env, jni::Make<jni::String>(*env, *languageTag.language)));
android::Locale::New(*env, jni::Make<jni::String>(*env, *languageTag.language)));
} else {
locale = jni::NewGlobal(*env,
android::Locale::New(*env, jni::Make<jni::String>(*env, *languageTag.language),
jni::Make<jni::String>(*env, *languageTag.region)));
android::Locale::New(*env,
jni::Make<jni::String>(*env, *languageTag.language),
jni::Make<jni::String>(*env, *languageTag.region)));
}
collator = jni::NewGlobal(*env, android::Collator::getInstance(*env, locale));
if (!diacriticSensitive && !caseSensitive) {
@@ -120,26 +122,27 @@ public:
} else if (diacriticSensitive && !caseSensitive) {
android::Collator::setStrength(*env, collator, 1 /*SECONDARY*/);
} else if (caseSensitive) {
// If we're case-sensitive and diacritic-sensitive, we use a case-sensitive collator
// and a fallback implementation of diacritic-insensitivity.
// If we're case-sensitive and diacritic-sensitive, we use a
// case-sensitive collator and a fallback implementation of
// diacritic-insensitivity.
android::Collator::setStrength(*env, collator, 2 /*TERTIARY*/);
}
}
bool operator==(const Impl& other) const {
return caseSensitive == other.caseSensitive &&
diacriticSensitive == other.diacriticSensitive &&
resolvedLocale() == other.resolvedLocale();
return caseSensitive == other.caseSensitive && diacriticSensitive == other.diacriticSensitive &&
resolvedLocale() == other.resolvedLocale();
}
int compare(const std::string& lhs, const std::string& rhs) const {
bool useUnaccent = !diacriticSensitive && caseSensitive;
// java.text.Collator doesn't support a diacritic-insensitive/case-sensitive collation
// order, so we have to compromise here. We use Android's case-sensitive Collator
// against strings that have been "unaccented" using non-locale-aware nunicode logic.
// Because of the difference in locale-awareness, this means turning on case-sensitivity
// can _potentially_ change compare results for strings that don't actually have any case
// differences.
// java.text.Collator doesn't support a
// diacritic-insensitive/case-sensitive collation order, so we have to
// compromise here. We use Android's case-sensitive Collator against
// strings that have been "unaccented" using non-locale-aware nunicode
// logic. Because of the difference in locale-awareness, this means
// turning on case-sensitivity can _potentially_ change compare results
// for strings that don't actually have any case differences.
jni::Local<jni::String> jlhs = useUnaccent
? android::StringUtils::unaccent(*env, jni::Make<jni::String>(*env, lhs))
: jni::Make<jni::String>(*env, lhs);

4
platform/android/MapboxGLAndroidSDK/src/cpp/i18n/collator_jni.hpp
View File

@@ -29,7 +29,6 @@ public:
static jni::Local<jni::Object<Locale>> New(jni::JNIEnv&, const jni::String&);
static jni::Local<jni::Object<Locale>> New(jni::JNIEnv&, const jni::String&, const jni::String&);
static void registerNative(jni::JNIEnv&);
};
@@ -43,18 +42,15 @@ public:
static jni::jint compare(jni::JNIEnv&, const jni::Object<Collator>&, const jni::String&, const jni::String&);
static void registerNative(jni::JNIEnv&);
};
class StringUtils {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/utils/StringUtils"; };
static jni::Local<jni::String> unaccent(jni::JNIEnv&, const jni::String&);
static void registerNative(jni::JNIEnv&);
};

34
platform/android/MapboxGLAndroidSDK/src/cpp/i18n/number_format.cpp
View File

@@ -15,31 +15,35 @@ void NumberFormat::registerNative(jni::JNIEnv& env) {
jni::Local<jni::Object<NumberFormat>> NumberFormat::getInstance(jni::JNIEnv& env, const jni::Object<Locale>& locale) {
static auto& javaClass = jni::Class<NumberFormat>::Singleton(env);
static auto method = javaClass.GetStaticMethod<jni::Object<NumberFormat> (jni::Object<Locale>)>(env, "getInstance");
static auto method = javaClass.GetStaticMethod<jni::Object<NumberFormat>(jni::Object<Locale>)>(env, "getInstance");
return javaClass.Call(env, method, locale);
}
jni::Local<jni::Object<NumberFormat>> NumberFormat::getCurrencyInstance(jni::JNIEnv& env, const jni::Object<Locale>& locale) {
jni::Local<jni::Object<NumberFormat>> NumberFormat::getCurrencyInstance(jni::JNIEnv& env,
const jni::Object<Locale>& locale) {
static auto& javaClass = jni::Class<NumberFormat>::Singleton(env);
static auto method = javaClass.GetStaticMethod<jni::Object<NumberFormat> (jni::Object<Locale>)>(env, "getCurrencyInstance");
static auto method = javaClass.GetStaticMethod<jni::Object<NumberFormat>(jni::Object<Locale>)>(
env, "getCurrencyInstance");
return javaClass.Call(env, method, locale);
}
jni::Local<jni::String> NumberFormat::format(jni::JNIEnv& env, const jni::Object<NumberFormat>& nf, jni::jdouble number) {
jni::Local<jni::String> NumberFormat::format(jni::JNIEnv& env,
const jni::Object<NumberFormat>& nf,
jni::jdouble number) {
static auto& javaClass = jni::Class<NumberFormat>::Singleton(env);
static auto method = javaClass.GetMethod<jni::String (jni::jdouble)>(env, "format");
static auto method = javaClass.GetMethod<jni::String(jni::jdouble)>(env, "format");
return nf.Call(env, method, number);
}
void NumberFormat::setMinimumFractionDigits(jni::JNIEnv& env, const jni::Object<NumberFormat>& nf, jni::jint value) {
static auto& javaClass = jni::Class<NumberFormat>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::jint)>(env, "setMinimumFractionDigits");
static auto method = javaClass.GetMethod<void(jni::jint)>(env, "setMinimumFractionDigits");
return nf.Call(env, method, value);
}
void NumberFormat::setMaximumFractionDigits(jni::JNIEnv& env, const jni::Object<NumberFormat>& nf, jni::jint value) {
static auto& javaClass = jni::Class<NumberFormat>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::jint)>(env, "setMaximumFractionDigits");
static auto method = javaClass.GetMethod<void(jni::jint)>(env, "setMaximumFractionDigits");
return nf.Call(env, method, value);
}
@@ -47,10 +51,12 @@ void NumberFormat::setMaximumFractionDigits(jni::JNIEnv& env, const jni::Object<
namespace platform {
std::string formatNumber(double number, const std::string& localeId, const std::string& currency,
uint8_t minFractionDigits, uint8_t maxFractionDigits) {
auto env{ android::AttachEnv() };
std::string formatNumber(double number,
const std::string& localeId,
const std::string& currency,
uint8_t minFractionDigits,
uint8_t maxFractionDigits) {
auto env{android::AttachEnv()};
jni::Global<jni::Object<android::Locale>> locale;
LanguageTag languageTag = !localeId.empty() ? LanguageTag::fromBCP47(localeId) : LanguageTag();
@@ -59,8 +65,10 @@ std::string formatNumber(double number, const std::string& localeId, const std::
} else if (!languageTag.region) {
locale = jni::NewGlobal(*env, android::Locale::New(*env, jni::Make<jni::String>(*env, *languageTag.language)));
} else {
locale = jni::NewGlobal(*env, android::Locale::New(*env, jni::Make<jni::String>(*env, *languageTag.language),
jni::Make<jni::String>(*env, *languageTag.region)));
locale = jni::NewGlobal(*env,
android::Locale::New(*env,
jni::Make<jni::String>(*env, *languageTag.language),
jni::Make<jni::String>(*env, *languageTag.region)));
}
jni::Global<jni::Object<android::NumberFormat>> formatter;

12
platform/android/MapboxGLAndroidSDK/src/cpp/java/util.hpp
View File

@@ -13,10 +13,10 @@ class List : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "java/util/List"; };
template<class T>
template <class T>
static jni::Local<jni::Array<jni::Object<T>>> toArray(jni::JNIEnv& env, const jni::Object<List>& list) {
static auto& javaClass = jni::Class<List>::Singleton(env);
static auto toArray = javaClass.GetMethod<jni::Array<jni::Object<>> ()>(env, "toArray");
static auto toArray = javaClass.GetMethod<jni::Array<jni::Object<>>()>(env, "toArray");
return jni::Local<jni::Array<jni::Object<T>>>(env, list.Call(env, toArray).release());
};
@@ -40,10 +40,10 @@ class Set : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "java/util/Set"; };
template<class T>
template <class T>
static jni::Local<jni::Array<jni::Object<T>>> toArray(jni::JNIEnv& env, const jni::Object<Set>& list) {
static auto& javaClass = jni::Class<Set>::Singleton(env);
static auto toArray = javaClass.GetMethod<jni::Array<jni::Object<>> ()>(env, "toArray");
static auto toArray = javaClass.GetMethod<jni::Array<jni::Object<>>()>(env, "toArray");
return jni::Local<jni::Array<jni::Object<T>>>(env, list.Call(env, toArray).release());
};
@@ -60,14 +60,14 @@ public:
template <class T>
static jni::Local<jni::Object<T>> getKey(jni::JNIEnv& env, const jni::Object<Entry>& entry) {
static auto& javaClass = jni::Class<Map::Entry>::Singleton(env);
static auto method = javaClass.GetMethod<jni::Object<> ()>(env, "getKey");
static auto method = javaClass.GetMethod<jni::Object<>()>(env, "getKey");
return jni::Cast(env, jni::Class<T>::Singleton(env), entry.Call(env, method));
}
template <class T>
static jni::Local<jni::Object<T>> getValue(jni::JNIEnv& env, const jni::Object<Entry>& entry) {
static auto& javaClass = jni::Class<Map::Entry>::Singleton(env);
static auto method = javaClass.GetMethod<jni::Object<> ()>(env, "getValue");
static auto method = javaClass.GetMethod<jni::Object<>()>(env, "getValue");
return jni::Cast(env, jni::Class<T>::Singleton(env), entry.Call(env, method));
}
};

62
platform/android/MapboxGLAndroidSDK/src/cpp/java_types.cpp
View File

@@ -4,46 +4,46 @@ namespace mbgl {
namespace android {
namespace java {
jni::jclass* ObjectArray::jclass;
jni::jclass* ObjectArray::jclass;
jni::jclass* String::jclass;
jni::jclass* String::jclass;
jni::jclass* Boolean::jclass;
jni::jmethodID* Boolean::booleanValueMethodId;
jni::jclass* Boolean::jclass;
jni::jmethodID* Boolean::booleanValueMethodId;
jni::jclass* Number::jclass;
jni::jmethodID* Number::floatValueMethodId;
jni::jmethodID* Number::doubleValueMethodId;
jni::jmethodID* Number::longValueMethodId;
jni::jclass* Number::jclass;
jni::jmethodID* Number::floatValueMethodId;
jni::jmethodID* Number::doubleValueMethodId;
jni::jmethodID* Number::longValueMethodId;
jni::jclass* Map::jclass;
jni::jmethodID* Map::getMethodId;
jni::jmethodID* Map::keySetMethodId;
jni::jclass* Map::jclass;
jni::jmethodID* Map::getMethodId;
jni::jmethodID* Map::keySetMethodId;
jni::jclass* Set::jclass;
jni::jmethodID* Set::toArrayMethodId;
jni::jclass* Set::jclass;
jni::jmethodID* Set::toArrayMethodId;
void registerNatives(JNIEnv& env) {
ObjectArray::jclass = jni::NewGlobalRef(env, &jni::FindClass(env, "[Ljava/lang/Object;")).release();
void registerNatives(JNIEnv& env) {
ObjectArray::jclass = jni::NewGlobalRef(env, &jni::FindClass(env, "[Ljava/lang/Object;")).release();
String::jclass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/lang/String")).release();
String::jclass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/lang/String")).release();
Boolean::jclass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/lang/Boolean")).release();
Boolean::booleanValueMethodId = &jni::GetMethodID(env, *Boolean::jclass, "booleanValue", "()Z");
Boolean::jclass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/lang/Boolean")).release();
Boolean::booleanValueMethodId = &jni::GetMethodID(env, *Boolean::jclass, "booleanValue", "()Z");
Number::jclass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/lang/Number")).release();
Number::floatValueMethodId = &jni::GetMethodID(env, *Number::jclass, "floatValue", "()F");
Number::doubleValueMethodId = &jni::GetMethodID(env, *Number::jclass, "doubleValue", "()D");
Number::longValueMethodId = &jni::GetMethodID(env, *Number::jclass, "longValue", "()J");
Number::jclass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/lang/Number")).release();
Number::floatValueMethodId = &jni::GetMethodID(env, *Number::jclass, "floatValue", "()F");
Number::doubleValueMethodId = &jni::GetMethodID(env, *Number::jclass, "doubleValue", "()D");
Number::longValueMethodId = &jni::GetMethodID(env, *Number::jclass, "longValue", "()J");
Map::jclass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/util/Map")).release();
Map::getMethodId = &jni::GetMethodID(env, *Map::jclass, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
Map::keySetMethodId = &jni::GetMethodID(env, *Map::jclass, "keySet", "()Ljava/util/Set;");
Set::jclass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/util/Set")).release();
Set::toArrayMethodId = &jni::GetMethodID(env, *Set::jclass, "toArray", "()[Ljava/lang/Object;");
}
Map::jclass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/util/Map")).release();
Map::getMethodId = &jni::GetMethodID(env, *Map::jclass, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
Map::keySetMethodId = &jni::GetMethodID(env, *Map::jclass, "keySet", "()Ljava/util/Set;");
Set::jclass = jni::NewGlobalRef(env, &jni::FindClass(env, "java/util/Set")).release();
Set::toArrayMethodId = &jni::GetMethodID(env, *Set::jclass, "toArray", "()[Ljava/lang/Object;");
}
}
}
} // namespace java
} // namespace android
} // namespace mbgl

58
platform/android/MapboxGLAndroidSDK/src/cpp/java_types.hpp
View File

@@ -6,38 +6,38 @@ namespace mbgl {
namespace android {
namespace java {
struct ObjectArray {
static jni::jclass* jclass;
};
struct ObjectArray {
static jni::jclass* jclass;
};
struct String {
static jni::jclass* jclass;
};
struct String {
static jni::jclass* jclass;
};
struct Boolean {
static jni::jclass* jclass;
static jni::jmethodID* booleanValueMethodId;
};
struct Boolean {
static jni::jclass* jclass;
static jni::jmethodID* booleanValueMethodId;
};
struct Number {
static jni::jclass* jclass;
static jni::jmethodID* floatValueMethodId;
static jni::jmethodID* doubleValueMethodId;
static jni::jmethodID* longValueMethodId;
};
struct Number {
static jni::jclass* jclass;
static jni::jmethodID* floatValueMethodId;
static jni::jmethodID* doubleValueMethodId;
static jni::jmethodID* longValueMethodId;
};
struct Map {
static jni::jclass* jclass;
static jni::jmethodID* getMethodId;
static jni::jmethodID* keySetMethodId;
};
struct Map {
static jni::jclass* jclass;
static jni::jmethodID* getMethodId;
static jni::jmethodID* keySetMethodId;
};
struct Set {
static jni::jclass* jclass;
static jni::jmethodID* toArrayMethodId;
};
struct Set {
static jni::jclass* jclass;
static jni::jmethodID* toArrayMethodId;
};
void registerNatives(JNIEnv&);
}
}
}
void registerNatives(JNIEnv&);
} // namespace java
} // namespace android
} // namespace mbgl

4
platform/android/MapboxGLAndroidSDK/src/cpp/jni_native.cpp
View File

@@ -62,7 +62,7 @@ namespace android {
void RegisterNativeHTTPRequest(JNIEnv&);
void registerNatives(JavaVM *vm) {
void registerNatives(JavaVM* vm) {
theJVM = vm;
jni::JNIEnv& env = jni::GetEnv(*vm, jni::jni_version_1_6);
@@ -101,7 +101,7 @@ void registerNatives(JavaVM *vm) {
gson::JsonObject::registerNative(env);
gson::JsonPrimitive::registerNative(env);
//Annotation
// Annotation
Marker::registerNative(env);
Polygon::registerNative(env);
Polyline::registerNative(env);

4
platform/android/MapboxGLAndroidSDK/src/cpp/logger.cpp
View File

@@ -8,7 +8,7 @@ void Logger::registerNative(jni::JNIEnv& env) {
jni::Class<Logger>::Singleton(env);
}
void Logger::log(jni::JNIEnv& env, EventSeverity severity, const std::string &msg) {
void Logger::log(jni::JNIEnv& env, EventSeverity severity, const std::string& msg) {
static auto& _class = jni::Class<Logger>::Singleton(env);
auto tag = jni::Make<jni::String>(env, "Mbgl");
@@ -21,7 +21,7 @@ void Logger::log(jni::JNIEnv& env, EventSeverity severity, const std::string &ms
} else if (severity == EventSeverity::Info) {
auto static info = _class.GetStaticMethod<Signature>(env, "i");
_class.Call(env, info, tag, message);
} else if(severity == EventSeverity::Warning) {
} else if (severity == EventSeverity::Warning) {
auto static warning = _class.GetStaticMethod<Signature>(env, "w");
_class.Call(env, warning, tag, message);
} else {

8
platform/android/MapboxGLAndroidSDK/src/cpp/logger.hpp
View File

@@ -9,12 +9,10 @@ namespace android {
class Logger {
public:
static constexpr auto Name() {
return "com/mapbox/mapboxsdk/log/Logger";
};
static void registerNative(jni::JNIEnv&);
static constexpr auto Name() { return "com/mapbox/mapboxsdk/log/Logger"; };
static void registerNative(jni::JNIEnv &);
static void log(jni::JNIEnv&, EventSeverity severity, const std::string &msg);
static void log(jni::JNIEnv &, EventSeverity severity, const std::string &msg);
};
} // namespace android

4
platform/android/MapboxGLAndroidSDK/src/cpp/logging_android.cpp
View File

@@ -6,8 +6,8 @@
namespace mbgl {
void Log::platformRecord(EventSeverity severity, const std::string &msg) {
auto env{ android::AttachEnv() };
auto env{android::AttachEnv()};
android::Logger::log(*env, severity, msg);
}
}
} // namespace mbgl

21
platform/android/MapboxGLAndroidSDK/src/cpp/map/camera_position.cpp
View File

@@ -4,9 +4,12 @@
namespace mbgl {
namespace android {
jni::Local<jni::Object<CameraPosition>> CameraPosition::New(jni::JNIEnv &env, mbgl::CameraOptions options, float pixelRatio) {
jni::Local<jni::Object<CameraPosition>> CameraPosition::New(jni::JNIEnv& env,
mbgl::CameraOptions options,
float pixelRatio) {
static auto& javaClass = jni::Class<CameraPosition>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::Object<LatLng>, double, double, double, jni::Array<jni::jdouble>>(env);
static auto constructor =
javaClass.GetConstructor<jni::Object<LatLng>, double, double, double, jni::Array<jni::jdouble>>(env);
// wrap LatLng values coming from core
auto center = options.center.value();
@@ -26,7 +29,7 @@ jni::Local<jni::Object<CameraPosition>> CameraPosition::New(jni::JNIEnv &env, mb
double tilt_degrees = options.pitch.value_or(0);
std::vector<jdouble> paddingVect;
auto insets = options.padding.value_or(EdgeInsets {0, 0, 0, 0});
auto insets = options.padding.value_or(EdgeInsets{0, 0, 0, 0});
auto padding = jni::Array<jni::jdouble>::New(env, 4);
paddingVect.push_back(insets.left() * pixelRatio);
paddingVect.push_back(insets.top() * pixelRatio);
@@ -34,10 +37,13 @@ jni::Local<jni::Object<CameraPosition>> CameraPosition::New(jni::JNIEnv &env, mb
paddingVect.push_back(insets.bottom() * pixelRatio);
padding.SetRegion<std::vector<jni::jdouble>>(env, 0, paddingVect);
return javaClass.New(env, constructor, LatLng::New(env, center), options.zoom.value_or(0), tilt_degrees, bearing_degrees, padding);
return javaClass.New(
env, constructor, LatLng::New(env, center), options.zoom.value_or(0), tilt_degrees, bearing_degrees, padding);
}
mbgl::CameraOptions CameraPosition::getCameraOptions(jni::JNIEnv& env, const jni::Object<CameraPosition>& position, float pixelRatio) {
mbgl::CameraOptions CameraPosition::getCameraOptions(jni::JNIEnv& env,
const jni::Object<CameraPosition>& position,
float pixelRatio) {
static auto& javaClass = jni::Class<CameraPosition>::Singleton(env);
static auto bearing = javaClass.GetField<jni::jdouble>(env, "bearing");
static auto target = javaClass.GetField<jni::Object<LatLng>>(env, "target");
@@ -60,10 +66,9 @@ mbgl::CameraOptions CameraPosition::getCameraOptions(jni::JNIEnv& env, const jni
position.Get(env, tilt)};
}
void CameraPosition::registerNative(jni::JNIEnv &env) {
void CameraPosition::registerNative(jni::JNIEnv& env) {
jni::Class<CameraPosition>::Singleton(env);
}
} // namespace android
} // namespace mb
} // namespace mbgl

28
platform/android/MapboxGLAndroidSDK/src/cpp/map/image.cpp
View File

@@ -13,7 +13,7 @@ mbgl::style::Image Image::getImage(jni::JNIEnv& env, const jni::Object<Image>& i
static auto bufferField = javaClass.GetField<jni::Array<jbyte>>(env, "buffer");
static auto nameField = javaClass.GetField<jni::String>(env, "name");
static auto sdfField = javaClass.GetField<jni::jboolean>(env, "sdf");
static auto contentField = javaClass.GetField<jni::Array<jfloat >>(env, "content");
static auto contentField = javaClass.GetField<jni::Array<jfloat>>(env, "content");
static auto stretchXField = javaClass.GetField<jni::Array<jfloat>>(env, "stretchX");
static auto stretchYField = javaClass.GetField<jni::Array<jfloat>>(env, "stretchY");
@@ -22,20 +22,19 @@ mbgl::style::Image Image::getImage(jni::JNIEnv& env, const jni::Object<Image>& i
auto pixelRatio = image.Get(env, pixelRatioField);
auto pixels = image.Get(env, bufferField);
auto name = jni::Make<std::string>(env, image.Get(env, nameField));
auto sdf = (bool) image.Get(env, sdfField);
auto sdf = (bool)image.Get(env, sdfField);
auto content = image.Get(env, contentField);
auto stretchX = image.Get(env, stretchXField);
auto stretchY = image.Get(env, stretchYField);
jni::NullCheck(env, pixels.get());
std::size_t size = pixels.Length(env);
mbgl::PremultipliedImage premultipliedImage({ static_cast<uint32_t>(width), static_cast<uint32_t>(height) });
mbgl::PremultipliedImage premultipliedImage({static_cast<uint32_t>(width), static_cast<uint32_t>(height)});
if (premultipliedImage.bytes() != uint32_t(size)) {
throw mbgl::util::StyleImageException("Image pixel count mismatch");
}
jni::GetArrayRegion(env, *pixels, 0, size,
reinterpret_cast<jbyte *>(premultipliedImage.data.get()));
jni::GetArrayRegion(env, *pixels, 0, size, reinterpret_cast<jbyte*>(premultipliedImage.data.get()));
style::ImageStretches imageStretchesX = {};
style::ImageStretches imageStretchesY = {};
@@ -53,24 +52,23 @@ mbgl::style::Image Image::getImage(jni::JNIEnv& env, const jni::Object<Image>& i
}
if (content) {
const style::ImageContent imageContent = style::ImageContent{content.Get(env, 0),
content.Get(env, 1),
content.Get(env, 2),
content.Get(env, 3)};
return mbgl::style::Image{name, std::move(premultipliedImage), pixelRatio, sdf,
const style::ImageContent imageContent = style::ImageContent{
content.Get(env, 0), content.Get(env, 1), content.Get(env, 2), content.Get(env, 3)};
return mbgl::style::Image{name,
std::move(premultipliedImage),
pixelRatio,
sdf,
imageStretchesX,
imageStretchesY,
std::move(imageContent)};
}
return mbgl::style::Image{name, std::move(premultipliedImage), pixelRatio, sdf,
imageStretchesX,
imageStretchesY};
return mbgl::style::Image{name, std::move(premultipliedImage), pixelRatio, sdf, imageStretchesX, imageStretchesY};
}
void Image::registerNative(jni::JNIEnv &env) {
void Image::registerNative(jni::JNIEnv& env) {
jni::Class<Image>::Singleton(env);
}
} // namespace android
} // namespace mb
} // namespace mbgl

54
platform/android/MapboxGLAndroidSDK/src/cpp/map_renderer.cpp
View File

@@ -24,7 +24,8 @@ MapRenderer::MapRenderer(jni::JNIEnv& _env,
: std::optional<std::string>{}),
mailboxData(this) {}
MapRenderer::MailboxData::MailboxData(Scheduler* scheduler_) : scheduler(scheduler_) {
MapRenderer::MailboxData::MailboxData(Scheduler* scheduler_)
: scheduler(scheduler_) {
assert(scheduler);
}
@@ -70,8 +71,7 @@ void MapRenderer::schedule(std::function<void()> scheduled) {
// Queue the event on the Java Peer
static auto& javaClass = jni::Class<MapRenderer>::Singleton(*_env);
static auto queueEvent = javaClass.GetMethod<void(
jni::Object<MapRendererRunnable>)>(*_env, "queueEvent");
static auto queueEvent = javaClass.GetMethod<void(jni::Object<MapRendererRunnable>)>(*_env, "queueEvent");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, queueEvent, peer);
@@ -127,16 +127,17 @@ void MapRenderer::setObserver(std::shared_ptr<RendererObserver> _rendererObserve
void MapRenderer::requestSnapshot(SnapshotCallback callback) {
auto self = ActorRef<MapRenderer>(*this, mailboxData.getMailbox());
self.invoke(
&MapRenderer::scheduleSnapshot,
std::make_unique<SnapshotCallback>([&, callback=std::move(callback), runloop=util::RunLoop::Get()](PremultipliedImage image) {
runloop->invoke([callback=std::move(callback), image=std::move(image), renderer=std::move(this)]() mutable {
if (renderer && !renderer->destroyed) {
callback(std::move(image));
}
});
&MapRenderer::scheduleSnapshot,
std::make_unique<SnapshotCallback>(
[&, callback = std::move(callback), runloop = util::RunLoop::Get()](PremultipliedImage image) {
runloop->invoke(
[callback = std::move(callback), image = std::move(image), renderer = std::move(this)]() mutable {
if (renderer && !renderer->destroyed) {
callback(std::move(image));
}
});
snapshotCallback.reset();
})
);
}));
}
// Called on OpenGL thread //
@@ -152,7 +153,7 @@ void MapRenderer::scheduleSnapshot(std::unique_ptr<SnapshotCallback> callback) {
}
void MapRenderer::render(JNIEnv&) {
assert (renderer);
assert(renderer);
std::shared_ptr<UpdateParameters> params;
{
@@ -165,7 +166,7 @@ void MapRenderer::render(JNIEnv&) {
}
// Activate the backend
gfx::BackendScope backendGuard { *backend };
gfx::BackendScope backendGuard{*backend};
// Ensure that the "current" scheduler on the render thread is
// this scheduler.
@@ -190,7 +191,7 @@ void MapRenderer::onSurfaceCreated(JNIEnv&) {
std::lock_guard<std::mutex> lock(initialisationMutex);
// The GL context is already active if get a new surface.
gfx::BackendScope backendGuard { *backend, gfx::BackendScope::ScopeType::Implicit };
gfx::BackendScope backendGuard{*backend, gfx::BackendScope::ScopeType::Implicit};
// The android system will have already destroyed the underlying
// GL resources if this is not the first initialization and an
@@ -244,17 +245,18 @@ void MapRenderer::registerNative(jni::JNIEnv& env) {
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
// Register the peer
jni::RegisterNativePeer<MapRenderer>(env, javaClass, "nativePtr",
jni::MakePeer<MapRenderer, const jni::Object<MapRenderer>&, jni::jfloat, const jni::String&>,
"nativeInitialize", "finalize",
METHOD(&MapRenderer::render, "nativeRender"),
METHOD(&MapRenderer::onRendererReset, "nativeReset"),
METHOD(&MapRenderer::onSurfaceCreated,
"nativeOnSurfaceCreated"),
METHOD(&MapRenderer::onSurfaceChanged,
"nativeOnSurfaceChanged"),
METHOD(&MapRenderer::onSurfaceDestroyed,
"nativeOnSurfaceDestroyed"));
jni::RegisterNativePeer<MapRenderer>(
env,
javaClass,
"nativePtr",
jni::MakePeer<MapRenderer, const jni::Object<MapRenderer>&, jni::jfloat, const jni::String&>,
"nativeInitialize",
"finalize",
METHOD(&MapRenderer::render, "nativeRender"),
METHOD(&MapRenderer::onRendererReset, "nativeReset"),
METHOD(&MapRenderer::onSurfaceCreated, "nativeOnSurfaceCreated"),
METHOD(&MapRenderer::onSurfaceChanged, "nativeOnSurfaceChanged"),
METHOD(&MapRenderer::onSurfaceDestroyed, "nativeOnSurfaceDestroyed"));
}
MapRenderer& MapRenderer::getNativePeer(JNIEnv& env, const jni::Object<MapRenderer>& jObject) {

5
platform/android/MapboxGLAndroidSDK/src/cpp/map_renderer.hpp
View File

@@ -34,7 +34,6 @@ class AndroidRendererBackend;
*/
class MapRenderer : public Scheduler {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/maps/renderer/MapRenderer"; };
static void registerNative(jni::JNIEnv&);
@@ -73,7 +72,7 @@ public:
void requestRender();
// Snapshot - requires a RunLoop on the calling thread
using SnapshotCallback = std::function<void (PremultipliedImage)>;
using SnapshotCallback = std::function<void(PremultipliedImage)>;
void requestSnapshot(SnapshotCallback);
protected:
@@ -128,7 +127,7 @@ private:
std::mutex updateMutex;
bool framebufferSizeChanged = false;
std::atomic<bool> destroyed {false};
std::atomic<bool> destroyed{false};
std::unique_ptr<SnapshotCallback> snapshotCallback;
mapbox::base::WeakPtrFactory<Scheduler> weakFactory{this};

15
platform/android/MapboxGLAndroidSDK/src/cpp/map_renderer_runnable.cpp
View File

@@ -35,14 +35,13 @@ void MapRendererRunnable::registerNative(jni::JNIEnv& env) {
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
jni::RegisterNativePeer<MapRendererRunnable>(
env,
javaClass,
"nativePtr",
std::make_unique<MapRendererRunnable, JNIEnv&>,
"nativeInitialize",
"finalize",
METHOD(&MapRendererRunnable::run, "run"));
jni::RegisterNativePeer<MapRendererRunnable>(env,
javaClass,
"nativePtr",
std::make_unique<MapRendererRunnable, JNIEnv&>,
"nativeInitialize",
"finalize",
METHOD(&MapRendererRunnable::run, "run"));
}
} // namespace android

5
platform/android/MapboxGLAndroidSDK/src/cpp/map_renderer_runnable.hpp
View File

@@ -19,7 +19,6 @@ namespace android {
*/
class MapRendererRunnable {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/maps/renderer/MapRendererRunnable"; };
static void registerNative(jni::JNIEnv&);
@@ -27,9 +26,7 @@ public:
MapRendererRunnable(jni::JNIEnv&, std::function<void()>);
// Only for jni registration, unused
MapRendererRunnable(jni::JNIEnv&) {
assert(false);
}
MapRendererRunnable(jni::JNIEnv&) { assert(false); }
~MapRendererRunnable();

341
platform/android/MapboxGLAndroidSDK/src/cpp/native_map_view.cpp
View File

@@ -63,7 +63,9 @@ NativeMapView::NativeMapView(jni::JNIEnv& _env,
const jni::Object<MapRenderer>& jMapRenderer,
jni::jfloat pixelRatio_,
jni::jboolean crossSourceCollisions_)
: javaPeer(_env, _obj), mapRenderer(MapRenderer::getNativePeer(_env, jMapRenderer)), pixelRatio(pixelRatio_) {
: javaPeer(_env, _obj),
mapRenderer(MapRenderer::getNativePeer(_env, jMapRenderer)),
pixelRatio(pixelRatio_) {
// Get a reference to the JavaVM for callbacks
if (_env.GetJavaVM(&vm) < 0) {
_env.ExceptionDescribe();
@@ -83,10 +85,11 @@ NativeMapView::NativeMapView(jni::JNIEnv& _env,
.withCrossSourceCollisions(crossSourceCollisions_);
// Create the core map
map = std::make_unique<mbgl::Map>(
*rendererFrontend, *this, options,
mbgl::android::FileSource::getSharedResourceOptions(_env, jFileSource),
mbgl::android::FileSource::getSharedClientOptions(_env, jFileSource));
map = std::make_unique<mbgl::Map>(*rendererFrontend,
*this,
options,
mbgl::android::FileSource::getSharedResourceOptions(_env, jFileSource),
mbgl::android::FileSource::getSharedClientOptions(_env, jFileSource));
}
/**
@@ -102,20 +105,19 @@ void NativeMapView::onCameraWillChange(MapObserver::CameraChangeMode mode) {
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onCameraWillChange = javaClass.GetMethod<void (jboolean)>(*_env, "onCameraWillChange");
static auto onCameraWillChange = javaClass.GetMethod<void(jboolean)>(*_env, "onCameraWillChange");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onCameraWillChange, (jboolean) (mode != MapObserver::CameraChangeMode::Immediate));
weakReference.Call(*_env, onCameraWillChange, (jboolean)(mode != MapObserver::CameraChangeMode::Immediate));
}
}
void NativeMapView::onCameraIsChanging() {
assert(vm != nullptr);
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onCameraIsChanging = javaClass.GetMethod<void ()>(*_env, "onCameraIsChanging");
static auto onCameraIsChanging = javaClass.GetMethod<void()>(*_env, "onCameraIsChanging");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onCameraIsChanging);
@@ -127,11 +129,10 @@ void NativeMapView::onCameraDidChange(MapObserver::CameraChangeMode mode) {
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onCameraDidChange = javaClass.GetMethod<void (jboolean)>(*_env, "onCameraDidChange");
static auto onCameraDidChange = javaClass.GetMethod<void(jboolean)>(*_env, "onCameraDidChange");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onCameraDidChange,
(jboolean) (mode != MapObserver::CameraChangeMode::Immediate));
weakReference.Call(*_env, onCameraDidChange, (jboolean)(mode != MapObserver::CameraChangeMode::Immediate));
}
}
@@ -140,7 +141,7 @@ void NativeMapView::onWillStartLoadingMap() {
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onWillStartLoadingMap = javaClass.GetMethod<void ()>(*_env, "onWillStartLoadingMap");
static auto onWillStartLoadingMap = javaClass.GetMethod<void()>(*_env, "onWillStartLoadingMap");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onWillStartLoadingMap);
@@ -152,7 +153,7 @@ void NativeMapView::onDidFinishLoadingMap() {
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onDidFinishLoadingMap = javaClass.GetMethod<void ()>(*_env, "onDidFinishLoadingMap");
static auto onDidFinishLoadingMap = javaClass.GetMethod<void()>(*_env, "onDidFinishLoadingMap");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onDidFinishLoadingMap);
@@ -164,7 +165,7 @@ void NativeMapView::onDidFailLoadingMap(MapLoadError, const std::string& error)
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onDidFailLoadingMap = javaClass.GetMethod<void (jni::String)>(*_env, "onDidFailLoadingMap");
static auto onDidFailLoadingMap = javaClass.GetMethod<void(jni::String)>(*_env, "onDidFailLoadingMap");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onDidFailLoadingMap, jni::Make<jni::String>(*_env, error));
@@ -176,7 +177,7 @@ void NativeMapView::onWillStartRenderingFrame() {
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onWillStartRenderingFrame = javaClass.GetMethod<void ()>(*_env, "onWillStartRenderingFrame");
static auto onWillStartRenderingFrame = javaClass.GetMethod<void()>(*_env, "onWillStartRenderingFrame");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onWillStartRenderingFrame);
@@ -188,20 +189,20 @@ void NativeMapView::onDidFinishRenderingFrame(MapObserver::RenderFrameStatus sta
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onDidFinishRenderingFrame = javaClass.GetMethod<void (jboolean)>(*_env, "onDidFinishRenderingFrame");
static auto onDidFinishRenderingFrame = javaClass.GetMethod<void(jboolean)>(*_env, "onDidFinishRenderingFrame");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onDidFinishRenderingFrame, (jboolean) (status.mode != MapObserver::RenderMode::Partial));
weakReference.Call(
*_env, onDidFinishRenderingFrame, (jboolean)(status.mode != MapObserver::RenderMode::Partial));
}
}
void NativeMapView::onWillStartRenderingMap() {
assert(vm != nullptr);
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onWillStartRenderingMap = javaClass.GetMethod<void ()>(*_env, "onWillStartRenderingMap");
static auto onWillStartRenderingMap = javaClass.GetMethod<void()>(*_env, "onWillStartRenderingMap");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onWillStartRenderingMap);
@@ -213,10 +214,10 @@ void NativeMapView::onDidFinishRenderingMap(MapObserver::RenderMode mode) {
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onDidFinishRenderingMap = javaClass.GetMethod<void (jboolean)>(*_env, "onDidFinishRenderingMap");
static auto onDidFinishRenderingMap = javaClass.GetMethod<void(jboolean)>(*_env, "onDidFinishRenderingMap");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onDidFinishRenderingMap, (jboolean) (mode != MapObserver::RenderMode::Partial));
weakReference.Call(*_env, onDidFinishRenderingMap, (jboolean)(mode != MapObserver::RenderMode::Partial));
}
}
@@ -225,7 +226,7 @@ void NativeMapView::onDidBecomeIdle() {
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onDidBecomeIdle = javaClass.GetMethod<void ()>(*_env, "onDidBecomeIdle");
static auto onDidBecomeIdle = javaClass.GetMethod<void()>(*_env, "onDidBecomeIdle");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onDidBecomeIdle);
@@ -237,7 +238,7 @@ void NativeMapView::onDidFinishLoadingStyle() {
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onDidFinishLoadingStyle = javaClass.GetMethod<void ()>(*_env, "onDidFinishLoadingStyle");
static auto onDidFinishLoadingStyle = javaClass.GetMethod<void()>(*_env, "onDidFinishLoadingStyle");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onDidFinishLoadingStyle);
@@ -249,7 +250,7 @@ void NativeMapView::onSourceChanged(mbgl::style::Source& source) {
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onSourceChanged = javaClass.GetMethod<void (jni::String)>(*_env, "onSourceChanged");
static auto onSourceChanged = javaClass.GetMethod<void(jni::String)>(*_env, "onSourceChanged");
auto sourceId = jni::Make<jni::String>(*_env, source.getID());
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
@@ -262,7 +263,7 @@ void NativeMapView::onStyleImageMissing(const std::string& imageId) {
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onStyleImageMissing = javaClass.GetMethod<void (jni::String)>(*_env, "onStyleImageMissing");
static auto onStyleImageMissing = javaClass.GetMethod<void(jni::String)>(*_env, "onStyleImageMissing");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onStyleImageMissing, jni::Make<jni::String>(*_env, imageId));
@@ -274,7 +275,8 @@ bool NativeMapView::onCanRemoveUnusedStyleImage(const std::string& imageId) {
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onCanRemoveUnusedStyleImage = javaClass.GetMethod<jboolean (jni::String)>(*_env, "onCanRemoveUnusedStyleImage");
static auto onCanRemoveUnusedStyleImage = javaClass.GetMethod<jboolean(jni::String)>(*_env,
"onCanRemoveUnusedStyleImage");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
return weakReference.Call(*_env, onCanRemoveUnusedStyleImage, jni::Make<jni::String>(*_env, imageId));
@@ -288,7 +290,7 @@ bool NativeMapView::onCanRemoveUnusedStyleImage(const std::string& imageId) {
void NativeMapView::resizeView(jni::JNIEnv&, int w, int h) {
width = util::max(64, w);
height = util::max(64, h);
map->setSize({ static_cast<uint32_t>(width), static_cast<uint32_t>(height) });
map->setSize({static_cast<uint32_t>(width), static_cast<uint32_t>(height)});
}
jni::Local<jni::String> NativeMapView::getStyleUrl(jni::JNIEnv& env) {
@@ -328,13 +330,19 @@ void NativeMapView::setGestureInProgress(jni::JNIEnv&, jni::jboolean inProgress)
void NativeMapView::moveBy(jni::JNIEnv&, jni::jdouble dx, jni::jdouble dy, jni::jlong duration) {
mbgl::AnimationOptions animationOptions;
if (duration > 0) {
animationOptions.duration.emplace(mbgl::Milliseconds(duration));
animationOptions.easing.emplace(mbgl::util::UnitBezier {0.1, 0.4, 0.35, 1.0});
animationOptions.duration.emplace(mbgl::Milliseconds(duration));
animationOptions.easing.emplace(mbgl::util::UnitBezier{0.1, 0.4, 0.35, 1.0});
}
map->moveBy({dx, dy}, animationOptions);
}
void NativeMapView::jumpTo(jni::JNIEnv& env, jni::jdouble bearing, jni::jdouble latitude, jni::jdouble longitude, jni::jdouble pitch, jni::jdouble zoom, const jni::Array<jni::jdouble>& padding) {
void NativeMapView::jumpTo(jni::JNIEnv& env,
jni::jdouble bearing,
jni::jdouble latitude,
jni::jdouble longitude,
jni::jdouble pitch,
jni::jdouble zoom,
const jni::Array<jni::jdouble>& padding) {
mbgl::CameraOptions options;
if (bearing != -1) {
options.bearing = bearing;
@@ -342,8 +350,8 @@ void NativeMapView::jumpTo(jni::JNIEnv& env, jni::jdouble bearing, jni::jdouble
options.center = mbgl::LatLng(latitude, longitude);
if (padding) {
assert(padding.Length(env) == 4);
options.padding = mbgl::EdgeInsets{padding.Get(env, 0), padding.Get(env, 1),
padding.Get(env, 2), padding.Get(env, 3)};
options.padding = mbgl::EdgeInsets{
padding.Get(env, 0), padding.Get(env, 1), padding.Get(env, 2), padding.Get(env, 3)};
}
if (pitch != -1) {
options.pitch = pitch;
@@ -355,7 +363,15 @@ void NativeMapView::jumpTo(jni::JNIEnv& env, jni::jdouble bearing, jni::jdouble
map->jumpTo(options);
}
void NativeMapView::easeTo(jni::JNIEnv& env, jni::jdouble bearing, jni::jdouble latitude, jni::jdouble longitude, jni::jlong duration, jni::jdouble pitch, jni::jdouble zoom, const jni::Array<jni::jdouble>& padding, jni::jboolean easing) {
void NativeMapView::easeTo(jni::JNIEnv& env,
jni::jdouble bearing,
jni::jdouble latitude,
jni::jdouble longitude,
jni::jlong duration,
jni::jdouble pitch,
jni::jdouble zoom,
const jni::Array<jni::jdouble>& padding,
jni::jboolean easing) {
mbgl::CameraOptions cameraOptions;
if (bearing != -1) {
cameraOptions.bearing = bearing;
@@ -363,8 +379,8 @@ void NativeMapView::easeTo(jni::JNIEnv& env, jni::jdouble bearing, jni::jdouble
cameraOptions.center = mbgl::LatLng(latitude, longitude);
if (padding) {
assert(padding.Length(env) == 4);
cameraOptions.padding = mbgl::EdgeInsets{padding.Get(env, 0), padding.Get(env, 1),
padding.Get(env, 2), padding.Get(env, 3)};
cameraOptions.padding = mbgl::EdgeInsets{
padding.Get(env, 0), padding.Get(env, 1), padding.Get(env, 2), padding.Get(env, 3)};
}
if (pitch != -1) {
cameraOptions.pitch = pitch;
@@ -376,14 +392,21 @@ void NativeMapView::easeTo(jni::JNIEnv& env, jni::jdouble bearing, jni::jdouble
mbgl::AnimationOptions animationOptions;
animationOptions.duration.emplace(mbgl::Milliseconds(duration));
if (!easing) {
// add a linear interpolator instead of easing
animationOptions.easing.emplace(mbgl::util::UnitBezier { 0, 0, 1, 1 });
// add a linear interpolator instead of easing
animationOptions.easing.emplace(mbgl::util::UnitBezier{0, 0, 1, 1});
}
map->easeTo(cameraOptions, animationOptions);
}
void NativeMapView::flyTo(jni::JNIEnv& env, jni::jdouble bearing, jni::jdouble latitude, jni::jdouble longitude, jni::jlong duration, jni::jdouble pitch, jni::jdouble zoom, const jni::Array<jni::jdouble>& padding) {
void NativeMapView::flyTo(jni::JNIEnv& env,
jni::jdouble bearing,
jni::jdouble latitude,
jni::jdouble longitude,
jni::jlong duration,
jni::jdouble pitch,
jni::jdouble zoom,
const jni::Array<jni::jdouble>& padding) {
mbgl::CameraOptions cameraOptions;
if (bearing != -1) {
cameraOptions.bearing = bearing;
@@ -391,8 +414,8 @@ void NativeMapView::flyTo(jni::JNIEnv& env, jni::jdouble bearing, jni::jdouble l
cameraOptions.center = mbgl::LatLng(latitude, longitude);
if (padding) {
assert(padding.Length(env) == 4);
cameraOptions.padding = mbgl::EdgeInsets{padding.Get(env, 0), padding.Get(env, 1),
padding.Get(env, 2), padding.Get(env, 3)};
cameraOptions.padding = mbgl::EdgeInsets{
padding.Get(env, 0), padding.Get(env, 1), padding.Get(env, 2), padding.Get(env, 3)};
}
if (pitch != -1) {
cameraOptions.pitch = pitch;
@@ -410,23 +433,46 @@ jni::Local<jni::Object<LatLng>> NativeMapView::getLatLng(JNIEnv& env) {
return LatLng::New(env, *map->getCameraOptions(std::nullopt).center);
}
void NativeMapView::setLatLng(jni::JNIEnv& env, jni::jdouble latitude, jni::jdouble longitude, const jni::Array<jni::jdouble>& padding, jni::jlong duration) {
void NativeMapView::setLatLng(jni::JNIEnv& env,
jni::jdouble latitude,
jni::jdouble longitude,
const jni::Array<jni::jdouble>& padding,
jni::jlong duration) {
mbgl::CameraOptions cameraOptions;
cameraOptions.center = mbgl::LatLng(latitude, longitude);
if (padding) {
assert(padding.Length(env) == 4);
cameraOptions.padding = mbgl::EdgeInsets{padding.Get(env, 0), padding.Get(env, 1),
padding.Get(env, 2), padding.Get(env, 3)};
cameraOptions.padding = mbgl::EdgeInsets{
padding.Get(env, 0), padding.Get(env, 1), padding.Get(env, 2), padding.Get(env, 3)};
}
map->easeTo(cameraOptions, mbgl::AnimationOptions{mbgl::Milliseconds(duration)});
}
jni::Local<jni::Object<CameraPosition>> NativeMapView::getCameraForLatLngBounds(jni::JNIEnv& env, const jni::Object<LatLngBounds>& jBounds, double top, double left, double bottom, double right, double bearing, double tilt) {
jni::Local<jni::Object<CameraPosition>> NativeMapView::getCameraForLatLngBounds(
jni::JNIEnv& env,
const jni::Object<LatLngBounds>& jBounds,
double top,
double left,
double bottom,
double right,
double bearing,
double tilt) {
mbgl::EdgeInsets padding = {top, left, bottom, right};
return CameraPosition::New(env, map->cameraForLatLngBounds(mbgl::android::LatLngBounds::getLatLngBounds(env, jBounds), padding, bearing, tilt), pixelRatio);
return CameraPosition::New(
env,
map->cameraForLatLngBounds(mbgl::android::LatLngBounds::getLatLngBounds(env, jBounds), padding, bearing, tilt),
pixelRatio);
}
jni::Local<jni::Object<CameraPosition>> NativeMapView::getCameraForGeometry(jni::JNIEnv& env, const jni::Object<geojson::Geometry>& jGeometry, double top, double left, double bottom, double right, double bearing, double tilt) {
jni::Local<jni::Object<CameraPosition>> NativeMapView::getCameraForGeometry(
jni::JNIEnv& env,
const jni::Object<geojson::Geometry>& jGeometry,
double top,
double left,
double bottom,
double right,
double bearing,
double tilt) {
auto geometry = geojson::Geometry::convert(env, jGeometry);
mbgl::EdgeInsets padding = {top, left, bottom, right};
return CameraPosition::New(env, map->cameraForGeometry(geometry, padding, bearing, tilt), pixelRatio);
@@ -439,7 +485,7 @@ void NativeMapView::setReachability(jni::JNIEnv&, jni::jboolean reachable) {
}
void NativeMapView::resetPosition(jni::JNIEnv&) {
map->jumpTo(mbgl::CameraOptions().withCenter(mbgl::LatLng {}).withZoom(0.0).withBearing(0.0).withPitch(0.0));
map->jumpTo(mbgl::CameraOptions().withCenter(mbgl::LatLng{}).withZoom(0.0).withBearing(0.0).withPitch(0.0));
}
jni::jdouble NativeMapView::getPitch(jni::JNIEnv&) {
@@ -447,13 +493,12 @@ jni::jdouble NativeMapView::getPitch(jni::JNIEnv&) {
}
void NativeMapView::setPitch(jni::JNIEnv&, jni::jdouble pitch, jni::jlong duration) {
map->easeTo(mbgl::CameraOptions().withPitch(pitch),
mbgl::AnimationOptions{ mbgl::Milliseconds(duration) });
map->easeTo(mbgl::CameraOptions().withPitch(pitch), mbgl::AnimationOptions{mbgl::Milliseconds(duration)});
}
void NativeMapView::setZoom(jni::JNIEnv&, jni::jdouble zoom, jni::jdouble x, jni::jdouble y, jni::jlong duration) {
map->easeTo(mbgl::CameraOptions().withZoom(zoom).withAnchor(mbgl::ScreenCoordinate{ x, y }),
mbgl::AnimationOptions{ mbgl::Milliseconds(duration) });
map->easeTo(mbgl::CameraOptions().withZoom(zoom).withAnchor(mbgl::ScreenCoordinate{x, y}),
mbgl::AnimationOptions{mbgl::Milliseconds(duration)});
}
jni::jdouble NativeMapView::getZoom(jni::JNIEnv&) {
@@ -496,7 +541,8 @@ jni::jdouble NativeMapView::getMaxPitch(jni::JNIEnv&) {
return *map->getBounds().maxPitch;
}
void NativeMapView::rotateBy(jni::JNIEnv&, jni::jdouble sx, jni::jdouble sy, jni::jdouble ex, jni::jdouble ey, jni::jlong duration) {
void NativeMapView::rotateBy(
jni::JNIEnv&, jni::jdouble sx, jni::jdouble sy, jni::jdouble ex, jni::jdouble ey, jni::jlong duration) {
mbgl::ScreenCoordinate first(sx, sy);
mbgl::ScreenCoordinate second(ex, ey);
map->rotateBy(first, second, mbgl::AnimationOptions{mbgl::Milliseconds(duration)});
@@ -506,9 +552,11 @@ void NativeMapView::setBearing(jni::JNIEnv&, jni::jdouble degrees, jni::jlong du
map->easeTo(mbgl::CameraOptions().withBearing(degrees), mbgl::AnimationOptions{mbgl::Milliseconds(duration)});
}
void NativeMapView::setBearingXY(jni::JNIEnv&, jni::jdouble degrees, jni::jdouble cx, jni::jdouble cy, jni::jlong duration) {
void NativeMapView::setBearingXY(
jni::JNIEnv&, jni::jdouble degrees, jni::jdouble cx, jni::jdouble cy, jni::jlong duration) {
mbgl::ScreenCoordinate anchor(cx, cy);
map->easeTo(mbgl::CameraOptions().withBearing(degrees).withAnchor(anchor), mbgl::AnimationOptions{mbgl::Milliseconds(duration)});
map->easeTo(mbgl::CameraOptions().withBearing(degrees).withAnchor(anchor),
mbgl::AnimationOptions{mbgl::Milliseconds(duration)});
}
jni::jdouble NativeMapView::getBearing(jni::JNIEnv&) {
@@ -516,10 +564,14 @@ jni::jdouble NativeMapView::getBearing(jni::JNIEnv&) {
}
void NativeMapView::resetNorth(jni::JNIEnv&) {
map->easeTo(mbgl::CameraOptions().withBearing(0.0), mbgl::AnimationOptions {{mbgl::Milliseconds(500)}});
map->easeTo(mbgl::CameraOptions().withBearing(0.0), mbgl::AnimationOptions{{mbgl::Milliseconds(500)}});
}
void NativeMapView::setVisibleCoordinateBounds(JNIEnv& env, const jni::Array<jni::Object<LatLng>>& coordinates, const jni::Object<RectF>& padding, jdouble direction, jni::jlong duration) {
void NativeMapView::setVisibleCoordinateBounds(JNIEnv& env,
const jni::Array<jni::Object<LatLng>>& coordinates,
const jni::Object<RectF>& padding,
jdouble direction,
jni::jlong duration) {
NullCheck(env, &coordinates);
std::size_t count = coordinates.Length(env);
@@ -530,7 +582,10 @@ void NativeMapView::setVisibleCoordinateBounds(JNIEnv& env, const jni::Array<jni
latLngs.push_back(LatLng::getLatLng(env, coordinates.Get(env, i)));
}
mbgl::EdgeInsets mbglInsets = { RectF::getTop(env, padding), RectF::getLeft(env, padding), RectF::getBottom(env, padding), RectF::getRight(env, padding) };
mbgl::EdgeInsets mbglInsets = {RectF::getTop(env, padding),
RectF::getLeft(env, padding),
RectF::getBottom(env, padding),
RectF::getRight(env, padding)};
mbgl::CameraOptions cameraOptions = map->cameraForLatLngs(latLngs, mbglInsets);
if (direction >= 0) {
cameraOptions.bearing = direction;
@@ -540,7 +595,7 @@ void NativeMapView::setVisibleCoordinateBounds(JNIEnv& env, const jni::Array<jni
if (duration > 0) {
animationOptions.duration.emplace(mbgl::Milliseconds(duration));
// equivalent to kCAMediaTimingFunctionDefault in iOS
animationOptions.easing.emplace(mbgl::util::UnitBezier { 0.25, 0.1, 0.25, 0.1 });
animationOptions.easing.emplace(mbgl::util::UnitBezier{0.25, 0.1, 0.25, 0.1});
}
map->easeTo(cameraOptions, animationOptions);
@@ -574,7 +629,7 @@ void NativeMapView::scheduleSnapshot(jni::JNIEnv&) {
// invoke Mapview#OnSnapshotReady
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onSnapshotReady = javaClass.GetMethod<void (jni::Object<Bitmap>)>(*_env, "onSnapshotReady");
static auto onSnapshotReady = javaClass.GetMethod<void(jni::Object<Bitmap>)>(*_env, "onSnapshotReady");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onSnapshotReady, bitmap);
@@ -586,17 +641,19 @@ jni::Local<jni::Object<CameraPosition>> NativeMapView::getCameraPosition(jni::JN
return CameraPosition::New(env, map->getCameraOptions(std::nullopt), pixelRatio);
}
void NativeMapView::updateMarker(jni::JNIEnv& env, jni::jlong markerId, jni::jdouble lat, jni::jdouble lon, const jni::String& jid) {
void NativeMapView::updateMarker(
jni::JNIEnv& env, jni::jlong markerId, jni::jdouble lat, jni::jdouble lon, const jni::String& jid) {
if (markerId == -1) {
return;
}
std::string iconId = jni::Make<std::string>(env, jid);
// Because Java only has int, not unsigned int, we need to bump the annotation id up to a long.
map->updateAnnotation(markerId, mbgl::SymbolAnnotation { mbgl::Point<double>(lon, lat), iconId });
map->updateAnnotation(markerId, mbgl::SymbolAnnotation{mbgl::Point<double>(lon, lat), iconId});
}
jni::Local<jni::Array<jni::jlong>> NativeMapView::addMarkers(jni::JNIEnv& env, const jni::Array<jni::Object<Marker>>& jmarkers) {
jni::Local<jni::Array<jni::jlong>> NativeMapView::addMarkers(jni::JNIEnv& env,
const jni::Array<jni::Object<Marker>>& jmarkers) {
jni::NullCheck(env, &jmarkers);
std::size_t len = jmarkers.Length(env);
@@ -605,10 +662,8 @@ jni::Local<jni::Array<jni::jlong>> NativeMapView::addMarkers(jni::JNIEnv& env, c
for (std::size_t i = 0; i < len; i++) {
auto marker = jmarkers.Get(env, i);
ids.push_back(map->addAnnotation(mbgl::SymbolAnnotation {
Marker::getPosition(env, marker),
Marker::getIconId(env, marker)
}));
ids.push_back(map->addAnnotation(
mbgl::SymbolAnnotation{Marker::getPosition(env, marker), Marker::getIconId(env, marker)}));
}
auto result = jni::Array<jni::jlong>::New(env, len);
@@ -641,12 +696,17 @@ jni::jdouble NativeMapView::getMetersPerPixelAtLatitude(JNIEnv&, jni::jdouble la
return mbgl::Projection::getMetersPerPixelAtLatitude(lat, zoom);
}
jni::Local<jni::Object<ProjectedMeters>> NativeMapView::projectedMetersForLatLng(JNIEnv& env, jni::jdouble latitude, jni::jdouble longitude) {
mbgl::ProjectedMeters projectedMeters = mbgl::Projection::projectedMetersForLatLng(mbgl::LatLng(latitude, longitude));
jni::Local<jni::Object<ProjectedMeters>> NativeMapView::projectedMetersForLatLng(JNIEnv& env,
jni::jdouble latitude,
jni::jdouble longitude) {
mbgl::ProjectedMeters projectedMeters = mbgl::Projection::projectedMetersForLatLng(
mbgl::LatLng(latitude, longitude));
return ProjectedMeters::New(env, projectedMeters.northing(), projectedMeters.easting());
}
jni::Local<jni::Object<LatLng>> NativeMapView::latLngForProjectedMeters(JNIEnv& env, jdouble northing, jdouble easting) {
jni::Local<jni::Object<LatLng>> NativeMapView::latLngForProjectedMeters(JNIEnv& env,
jdouble northing,
jdouble easting) {
return LatLng::New(env, mbgl::Projection::latLngForProjectedMeters(mbgl::ProjectedMeters(northing, easting)));
}
@@ -711,7 +771,8 @@ void NativeMapView::latLngsForPixels(JNIEnv& env,
output.SetRegion<std::vector<jdouble>>(env, 0, buffer);
}
jni::Local<jni::Array<jlong>> NativeMapView::addPolylines(JNIEnv& env, const jni::Array<jni::Object<Polyline>>& polylines) {
jni::Local<jni::Array<jlong>> NativeMapView::addPolylines(JNIEnv& env,
const jni::Array<jni::Object<Polyline>>& polylines) {
NullCheck(env, &polylines);
std::size_t len = polylines.Length(env);
@@ -729,8 +790,8 @@ jni::Local<jni::Array<jlong>> NativeMapView::addPolylines(JNIEnv& env, const jni
return result;
}
jni::Local<jni::Array<jlong>> NativeMapView::addPolygons(JNIEnv& env, const jni::Array<jni::Object<Polygon>>& polygons) {
jni::Local<jni::Array<jlong>> NativeMapView::addPolygons(JNIEnv& env,
const jni::Array<jni::Object<Polygon>>& polygons) {
NullCheck(env, &polygons);
std::size_t len = polygons.Length(env);
@@ -765,27 +826,28 @@ void NativeMapView::removeAnnotations(JNIEnv& env, const jni::Array<jlong>& ids)
jlong* jids = std::get<0>(elements).get();
for (std::size_t i = 0; i < len; i++) {
if(jids[i] == -1L) {
continue;
if (jids[i] == -1L) {
continue;
}
map->removeAnnotation(jids[i]);
}
}
void NativeMapView::addAnnotationIcon(JNIEnv& env, const jni::String& symbol, jint w, jint h, jfloat scale, const jni::Array<jbyte>& jpixels) {
void NativeMapView::addAnnotationIcon(
JNIEnv& env, const jni::String& symbol, jint w, jint h, jfloat scale, const jni::Array<jbyte>& jpixels) {
const std::string symbolName = jni::Make<std::string>(env, symbol);
NullCheck(env, &jpixels);
std::size_t size = jpixels.Length(env);
mbgl::PremultipliedImage premultipliedImage({ static_cast<uint32_t>(w), static_cast<uint32_t>(h) });
mbgl::PremultipliedImage premultipliedImage({static_cast<uint32_t>(w), static_cast<uint32_t>(h)});
if (premultipliedImage.bytes() != uint32_t(size)) {
throw mbgl::util::StyleImageException("Annotation icon image pixel count mismatch");
}
jni::GetArrayRegion(env, *jpixels, 0, size, reinterpret_cast<jbyte*>(premultipliedImage.data.get()));
map->addAnnotationImage(std::make_unique<mbgl::style::Image>(
symbolName, std::move(premultipliedImage), static_cast<float>(scale)));
map->addAnnotationImage(
std::make_unique<mbgl::style::Image>(symbolName, std::move(premultipliedImage), static_cast<float>(scale)));
}
void NativeMapView::removeAnnotationIcon(JNIEnv& env, const jni::String& symbol) {
@@ -799,18 +861,21 @@ jdouble NativeMapView::getTopOffsetPixelsForAnnotationSymbol(JNIEnv& env, const
jni::Local<jni::Object<TransitionOptions>> NativeMapView::getTransitionOptions(JNIEnv& env) {
const auto transitionOptions = map->getStyle().getTransitionOptions();
const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(transitionOptions.duration.value_or(mbgl::Duration::zero())).count();
const auto delay = std::chrono::duration_cast<std::chrono::milliseconds>(transitionOptions.delay.value_or(mbgl::Duration::zero())).count();
const auto enablePlacementTransitions = (jboolean) transitionOptions.enablePlacementTransitions;
const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
transitionOptions.duration.value_or(mbgl::Duration::zero()))
.count();
const auto delay = std::chrono::duration_cast<std::chrono::milliseconds>(
transitionOptions.delay.value_or(mbgl::Duration::zero()))
.count();
const auto enablePlacementTransitions = (jboolean)transitionOptions.enablePlacementTransitions;
return TransitionOptions::fromTransitionOptions(env, duration, delay, enablePlacementTransitions);
}
void NativeMapView::setTransitionOptions(JNIEnv& env, const jni::Object<TransitionOptions>& options) {
const mbgl::style::TransitionOptions transitionOptions(
Duration(mbgl::Milliseconds(TransitionOptions::getDuration(env, options))),
Duration(mbgl::Milliseconds(TransitionOptions::getDelay(env, options))),
TransitionOptions::isEnablePlacementTransitions(env, options)
);
Duration(mbgl::Milliseconds(TransitionOptions::getDuration(env, options))),
Duration(mbgl::Milliseconds(TransitionOptions::getDelay(env, options))),
TransitionOptions::isEnablePlacementTransitions(env, options));
map->getStyle().setTransitionOptions(transitionOptions);
}
@@ -820,8 +885,8 @@ jni::Local<jni::Array<jlong>> NativeMapView::queryPointAnnotations(JNIEnv& env,
// Convert input
mbgl::ScreenBox box = {
{ RectF::getLeft(env, rect), RectF::getTop(env, rect) },
{ RectF::getRight(env, rect), RectF::getBottom(env, rect) },
{RectF::getLeft(env, rect), RectF::getTop(env, rect)},
{RectF::getRight(env, rect), RectF::getBottom(env, rect)},
};
// Assume only points for now
@@ -841,8 +906,8 @@ jni::Local<jni::Array<jlong>> NativeMapView::queryShapeAnnotations(JNIEnv& env,
// Convert input
mbgl::ScreenBox box = {
{RectF::getLeft(env, rect), RectF::getTop(env, rect)},
{RectF::getRight(env, rect), RectF::getBottom(env, rect)},
{RectF::getLeft(env, rect), RectF::getTop(env, rect)},
{RectF::getRight(env, rect), RectF::getBottom(env, rect)},
};
mbgl::AnnotationIDs ids = rendererFrontend->queryShapeAnnotations(box);
@@ -855,9 +920,12 @@ jni::Local<jni::Array<jlong>> NativeMapView::queryShapeAnnotations(JNIEnv& env,
return result;
}
jni::Local<jni::Array<jni::Object<geojson::Feature>>> NativeMapView::queryRenderedFeaturesForPoint(JNIEnv& env, jni::jfloat x, jni::jfloat y,
const jni::Array<jni::String>& layerIds,
const jni::Array<jni::Object<>>& jfilter) {
jni::Local<jni::Array<jni::Object<geojson::Feature>>> NativeMapView::queryRenderedFeaturesForPoint(
JNIEnv& env,
jni::jfloat x,
jni::jfloat y,
const jni::Array<jni::String>& layerIds,
const jni::Array<jni::Object<>>& jfilter) {
using namespace mbgl::android::conversion;
using namespace mbgl::android::geojson;
@@ -867,14 +935,17 @@ jni::Local<jni::Array<jni::Object<geojson::Feature>>> NativeMapView::queryRender
}
mapbox::geometry::point<double> point = {x, y};
return Feature::convert(
env,
rendererFrontend->queryRenderedFeatures(point, { layers, toFilter(env, jfilter) }));
return Feature::convert(env, rendererFrontend->queryRenderedFeatures(point, {layers, toFilter(env, jfilter)}));
}
jni::Local<jni::Array<jni::Object<geojson::Feature>>> NativeMapView::queryRenderedFeaturesForBox(JNIEnv& env, jni::jfloat left, jni::jfloat top,
jni::jfloat right, jni::jfloat bottom, const jni::Array<jni::String>& layerIds,
const jni::Array<jni::Object<>>& jfilter) {
jni::Local<jni::Array<jni::Object<geojson::Feature>>> NativeMapView::queryRenderedFeaturesForBox(
JNIEnv& env,
jni::jfloat left,
jni::jfloat top,
jni::jfloat right,
jni::jfloat bottom,
const jni::Array<jni::String>& layerIds,
const jni::Array<jni::Object<>>& jfilter) {
using namespace mbgl::android::conversion;
using namespace mbgl::android::geojson;
@@ -882,14 +953,10 @@ jni::Local<jni::Array<jni::Object<geojson::Feature>>> NativeMapView::queryRender
if (layerIds && layerIds.Length(env) > 0) {
layers = toVector(env, layerIds);
}
mapbox::geometry::box<double> box = {
mapbox::geometry::point<double>{ left, top},
mapbox::geometry::point<double>{ right, bottom }
};
mapbox::geometry::box<double> box = {mapbox::geometry::point<double>{left, top},
mapbox::geometry::point<double>{right, bottom}};
return Feature::convert(
env,
rendererFrontend->queryRenderedFeatures(box, { layers, toFilter(env, jfilter) }));
return Feature::convert(env, rendererFrontend->queryRenderedFeatures(box, {layers, toFilter(env, jfilter)}));
}
jni::Local<jni::Object<Light>> NativeMapView::getLight(JNIEnv& env) {
@@ -902,7 +969,6 @@ jni::Local<jni::Object<Light>> NativeMapView::getLight(JNIEnv& env) {
}
jni::Local<jni::Array<jni::Object<Layer>>> NativeMapView::getLayers(JNIEnv& env) {
// Get the core layers
std::vector<style::Layer*> layers = map->getStyle().getLayers();
@@ -918,12 +984,11 @@ jni::Local<jni::Array<jni::Object<Layer>>> NativeMapView::getLayers(JNIEnv& env)
}
jni::Local<jni::Object<Layer>> NativeMapView::getLayer(JNIEnv& env, const jni::String& layerId) {
// Find the layer
mbgl::style::Layer* coreLayer = map->getStyle().getLayer(jni::Make<std::string>(env, layerId));
if (!coreLayer) {
mbgl::Log::Debug(mbgl::Event::JNI, "No layer found");
return jni::Local<jni::Object<Layer>>();
mbgl::Log::Debug(mbgl::Event::JNI, "No layer found");
return jni::Local<jni::Object<Layer>>();
}
// Create and return the layer's native peer
@@ -933,20 +998,21 @@ jni::Local<jni::Object<Layer>> NativeMapView::getLayer(JNIEnv& env, const jni::S
void NativeMapView::addLayer(JNIEnv& env, jlong nativeLayerPtr, const jni::String& before) {
assert(nativeLayerPtr != 0);
Layer *layer = reinterpret_cast<Layer *>(nativeLayerPtr);
Layer* layer = reinterpret_cast<Layer*>(nativeLayerPtr);
try {
layer->addToStyle(
map->getStyle(),
before ? std::optional<std::string>(jni::Make<std::string>(env, before)) : std::optional<std::string>());
} catch (const std::runtime_error& error) {
jni::ThrowNew(env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"), error.what());
jni::ThrowNew(
env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"), error.what());
}
}
void NativeMapView::addLayerAbove(JNIEnv& env, jlong nativeLayerPtr, const jni::String& above) {
assert(nativeLayerPtr != 0);
Layer *layer = reinterpret_cast<Layer *>(nativeLayerPtr);
Layer* layer = reinterpret_cast<Layer*>(nativeLayerPtr);
// Find the sibling
auto layers = map->getStyle().getLayers();
@@ -964,34 +1030,37 @@ void NativeMapView::addLayerAbove(JNIEnv& env, jlong nativeLayerPtr, const jni::
std::optional<std::string> before;
if (index + 1 > layers.size()) {
// Not found
jni::ThrowNew(env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"),
std::string("Could not find layer: ").append(siblingId).c_str());
jni::ThrowNew(env,
jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"),
std::string("Could not find layer: ").append(siblingId).c_str());
return;
} else if (index + 1 < layers.size()) {
// Place before the sibling
before = { layers.at(index + 1)->getID() };
before = {layers.at(index + 1)->getID()};
}
// Add the layer
try {
layer->addToStyle(map->getStyle(), before);
} catch (const std::runtime_error& error) {
jni::ThrowNew(env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"), error.what());
jni::ThrowNew(
env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"), error.what());
}
}
void NativeMapView::addLayerAt(JNIEnv& env, jlong nativeLayerPtr, jni::jint index) {
assert(nativeLayerPtr != 0);
Layer *layer = reinterpret_cast<Layer *>(nativeLayerPtr);
Layer* layer = reinterpret_cast<Layer*>(nativeLayerPtr);
auto layers = map->getStyle().getLayers();
// Check index
int numLayers = layers.size() - 1;
if (index > numLayers || index < 0) {
Log::Error(Event::JNI, "Index out of range: " + std::to_string(index));
jni::ThrowNew(env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"),
std::string("Invalid index").c_str());
jni::ThrowNew(env,
jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"),
std::string("Invalid index").c_str());
return;
}
@@ -999,11 +1068,11 @@ void NativeMapView::addLayerAt(JNIEnv& env, jlong nativeLayerPtr, jni::jint inde
try {
layer->addToStyle(map->getStyle(), layers.at(index)->getID());
} catch (const std::runtime_error& error) {
jni::ThrowNew(env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"), error.what());
jni::ThrowNew(
env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/layers/CannotAddLayerException"), error.what());
}
}
/**
* Remove layer at index.
*/
@@ -1019,8 +1088,8 @@ jni::jboolean NativeMapView::removeLayerAt(JNIEnv& env, jni::jint index) {
std::unique_ptr<mbgl::style::Layer> coreLayer = map->getStyle().removeLayer(layers.at(index)->getID());
if (coreLayer) {
jni::Local<jni::Object<Layer>> layerObj =
LayerManagerAndroid::get()->createJavaLayerPeer(env, std::move(coreLayer));
jni::Local<jni::Object<Layer>> layerObj = LayerManagerAndroid::get()->createJavaLayerPeer(env,
std::move(coreLayer));
return jni::jni_true;
}
return jni::jni_false;
@@ -1032,7 +1101,7 @@ jni::jboolean NativeMapView::removeLayerAt(JNIEnv& env, jni::jint index) {
jni::jboolean NativeMapView::removeLayer(JNIEnv&, jlong layerPtr) {
assert(layerPtr != 0);
mbgl::android::Layer *layer = reinterpret_cast<mbgl::android::Layer *>(layerPtr);
mbgl::android::Layer* layer = reinterpret_cast<mbgl::android::Layer*>(layerPtr);
std::unique_ptr<mbgl::style::Layer> coreLayer = map->getStyle().removeLayer(layer->get().getID());
if (coreLayer) {
layer->setLayer(std::move(coreLayer));
@@ -1060,8 +1129,8 @@ jni::Local<jni::Object<Source>> NativeMapView::getSource(JNIEnv& env, const jni:
// Find the source
mbgl::style::Source* coreSource = map->getStyle().getSource(jni::Make<std::string>(env, sourceId));
if (!coreSource) {
mbgl::Log::Debug(mbgl::Event::JNI, "No source found");
return jni::Local<jni::Object<Source>>();
mbgl::Log::Debug(mbgl::Event::JNI, "No source found");
return jni::Local<jni::Object<Source>>();
}
// Create and return the source's native peer
@@ -1071,18 +1140,19 @@ jni::Local<jni::Object<Source>> NativeMapView::getSource(JNIEnv& env, const jni:
void NativeMapView::addSource(JNIEnv& env, const jni::Object<Source>& obj, jlong sourcePtr) {
assert(sourcePtr != 0);
Source *source = reinterpret_cast<Source *>(sourcePtr);
Source* source = reinterpret_cast<Source*>(sourcePtr);
try {
source->addToMap(env, obj, *map, *rendererFrontend);
} catch (const std::runtime_error& error) {
jni::ThrowNew(env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/sources/CannotAddSourceException"), error.what());
jni::ThrowNew(
env, jni::FindClass(env, "com/mapbox/mapboxsdk/style/sources/CannotAddSourceException"), error.what());
}
}
jni::jboolean NativeMapView::removeSource(JNIEnv& env, const jni::Object<Source>& obj, jlong sourcePtr) {
assert(sourcePtr != 0);
mbgl::android::Source *source = reinterpret_cast<mbgl::android::Source *>(sourcePtr);
mbgl::android::Source* source = reinterpret_cast<mbgl::android::Source*>(sourcePtr);
if (source->removeFromMap(env, obj, *map)) {
source->releaseJavaPeer();
return jni::jni_true;
@@ -1091,16 +1161,13 @@ jni::jboolean NativeMapView::removeSource(JNIEnv& env, const jni::Object<Source>
return jni::jni_false;
}
void NativeMapView::addImage(JNIEnv& env, const jni::String& name, const jni::Object<Bitmap>& bitmap, jni::jfloat scale, jni::jboolean sdf) {
void NativeMapView::addImage(
JNIEnv& env, const jni::String& name, const jni::Object<Bitmap>& bitmap, jni::jfloat scale, jni::jboolean sdf) {
jni::NullCheck(env, &bitmap);
mbgl::PremultipliedImage premultipliedImage = Bitmap::GetImage(env, bitmap);
map->getStyle().addImage(std::make_unique<mbgl::style::Image>(
jni::Make<std::string>(env, name),
std::move(premultipliedImage),
static_cast<float>(scale),
sdf)
);
jni::Make<std::string>(env, name), std::move(premultipliedImage), static_cast<float>(scale), sdf));
}
void NativeMapView::addImages(JNIEnv& env, const jni::Array<jni::Object<mbgl::android::Image>>& jimages) {
@@ -1155,7 +1222,7 @@ void NativeMapView::registerNative(jni::JNIEnv& env) {
// Lookup the class
static auto& javaClass = jni::Class<NativeMapView>::Singleton(env);
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
// Register the peer
jni::RegisterNativePeer<NativeMapView>(

67
platform/android/MapboxGLAndroidSDK/src/cpp/native_map_view.hpp
View File

@@ -40,7 +40,6 @@ class MapRenderer;
class NativeMapView : public MapObserver {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/maps/NativeMapView"; };
static void registerNative(jni::JNIEnv&);
@@ -91,19 +90,54 @@ public:
void moveBy(jni::JNIEnv&, jni::jdouble, jni::jdouble, jni::jlong);
void jumpTo(jni::JNIEnv&, jni::jdouble, jni::jdouble, jni::jdouble, jni::jdouble, jni::jdouble, const jni::Array<jni::jdouble>&);
void jumpTo(jni::JNIEnv&,
jni::jdouble,
jni::jdouble,
jni::jdouble,
jni::jdouble,
jni::jdouble,
const jni::Array<jni::jdouble>&);
void easeTo(jni::JNIEnv&, jni::jdouble, jni::jdouble, jni::jdouble, jni::jlong, jni::jdouble, jni::jdouble, const jni::Array<jni::jdouble>&, jni::jboolean);
void easeTo(jni::JNIEnv&,
jni::jdouble,
jni::jdouble,
jni::jdouble,
jni::jlong,
jni::jdouble,
jni::jdouble,
const jni::Array<jni::jdouble>&,
jni::jboolean);
void flyTo(jni::JNIEnv&, jni::jdouble, jni::jdouble, jni::jdouble, jni::jlong, jni::jdouble, jni::jdouble, const jni::Array<jni::jdouble>&);
void flyTo(jni::JNIEnv&,
jni::jdouble,
jni::jdouble,
jni::jdouble,
jni::jlong,
jni::jdouble,
jni::jdouble,
const jni::Array<jni::jdouble>&);
jni::Local<jni::Object<LatLng>> getLatLng(JNIEnv&);
void setLatLng(jni::JNIEnv&, jni::jdouble, jni::jdouble, const jni::Array<jni::jdouble>&, jni::jlong);
jni::Local<jni::Object<CameraPosition>> getCameraForLatLngBounds(jni::JNIEnv&, const jni::Object<mbgl::android::LatLngBounds>&, double top, double left, double bottom, double right, double bearing, double tilt);
jni::Local<jni::Object<CameraPosition>> getCameraForLatLngBounds(jni::JNIEnv&,
const jni::Object<mbgl::android::LatLngBounds>&,
double top,
double left,
double bottom,
double right,
double bearing,
double tilt);
jni::Local<jni::Object<CameraPosition>> getCameraForGeometry(jni::JNIEnv&, const jni::Object<geojson::Geometry>&, double top, double left, double bottom, double right, double bearing, double tilt);
jni::Local<jni::Object<CameraPosition>> getCameraForGeometry(jni::JNIEnv&,
const jni::Object<geojson::Geometry>&,
double top,
double left,
double bottom,
double right,
double bearing,
double tilt);
void setReachability(jni::JNIEnv&, jni::jboolean);
@@ -145,7 +179,8 @@ public:
void resetNorth(jni::JNIEnv&);
void setVisibleCoordinateBounds(JNIEnv&, const jni::Array<jni::Object<LatLng>>&, const jni::Object<RectF>&, jni::jdouble, jni::jlong);
void setVisibleCoordinateBounds(
JNIEnv&, const jni::Array<jni::Object<LatLng>>&, const jni::Object<RectF>&, jni::jdouble, jni::jlong);
void getVisibleCoordinateBounds(JNIEnv& env, jni::Array<jdouble>& output);
@@ -203,13 +238,17 @@ public:
jni::Local<jni::Array<jlong>> queryShapeAnnotations(JNIEnv&, const jni::Object<RectF>&);
jni::Local<jni::Array<jni::Object<geojson::Feature>>> queryRenderedFeaturesForPoint(JNIEnv&, jni::jfloat, jni::jfloat,
const jni::Array<jni::String>&,
const jni::Array<jni::Object<>>& jfilter);
jni::Local<jni::Array<jni::Object<geojson::Feature>>> queryRenderedFeaturesForPoint(
JNIEnv&, jni::jfloat, jni::jfloat, const jni::Array<jni::String>&, const jni::Array<jni::Object<>>& jfilter);
jni::Local<jni::Array<jni::Object<geojson::Feature>>> queryRenderedFeaturesForBox(JNIEnv&, jni::jfloat, jni::jfloat, jni::jfloat,
jni::jfloat, const jni::Array<jni::String>&,
const jni::Array<jni::Object<>>& jfilter);
jni::Local<jni::Array<jni::Object<geojson::Feature>>> queryRenderedFeaturesForBox(
JNIEnv&,
jni::jfloat,
jni::jfloat,
jni::jfloat,
jni::jfloat,
const jni::Array<jni::String>&,
const jni::Array<jni::Object<>>& jfilter);
jni::Local<jni::Object<Light>> getLight(JNIEnv&);
@@ -258,7 +297,7 @@ public:
private:
std::unique_ptr<AndroidRendererFrontend> rendererFrontend;
JavaVM *vm = nullptr;
JavaVM* vm = nullptr;
jni::WeakReference<jni::Object<NativeMapView>> javaPeer;
MapRenderer& mapRenderer;

218
platform/android/MapboxGLAndroidSDK/src/cpp/offline/offline_manager.cpp
View File

@@ -25,11 +25,10 @@ void handleException(std::exception_ptr exception,
// OfflineManager //
OfflineManager::OfflineManager(jni::JNIEnv& env, const jni::Object<FileSource>& jFileSource)
: fileSource(std::static_pointer_cast<mbgl::DatabaseFileSource>(
std::shared_ptr<mbgl::FileSource>(mbgl::FileSourceManager::get()->getFileSource(
mbgl::FileSourceType::Database,
FileSource::getSharedResourceOptions(env, jFileSource),
FileSource::getSharedClientOptions(env, jFileSource))))) {
: fileSource(std::static_pointer_cast<mbgl::DatabaseFileSource>(std::shared_ptr<mbgl::FileSource>(
mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::Database,
FileSource::getSharedResourceOptions(env, jFileSource),
FileSource::getSharedClientOptions(env, jFileSource))))) {
if (!fileSource) {
ThrowNew(env, jni::FindClass(env, "java/lang/IllegalStateException"), "Offline functionality is disabled.");
}
@@ -41,27 +40,28 @@ void OfflineManager::setOfflineMapboxTileCountLimit(jni::JNIEnv&, jni::jlong lim
fileSource->setOfflineMapboxTileCountLimit(limit);
}
void OfflineManager::listOfflineRegions(jni::JNIEnv& env_, const jni::Object<FileSource>& jFileSource_, const jni::Object<ListOfflineRegionsCallback>& callback_) {
void OfflineManager::listOfflineRegions(jni::JNIEnv& env_,
const jni::Object<FileSource>& jFileSource_,
const jni::Object<ListOfflineRegionsCallback>& callback_) {
auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
auto globalFilesource = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, jFileSource_);
fileSource->listOfflineRegions([
//Keep a shared ptr to a global reference of the callback and file source so they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback)),
jFileSource = std::make_shared<decltype(globalFilesource)>(std::move(globalFilesource))
](mbgl::expected<mbgl::OfflineRegions, std::exception_ptr> regions) mutable {
fileSource->listOfflineRegions(
[
// Keep a shared ptr to a global reference of the callback and file
// source so they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback)),
jFileSource = std::make_shared<decltype(globalFilesource)>(std::move(globalFilesource))](
mbgl::expected<mbgl::OfflineRegions, std::exception_ptr> regions) mutable {
// Reattach, the callback comes from a different thread
android::UniqueEnv env = android::AttachEnv();
// Reattach, the callback comes from a different thread
android::UniqueEnv env = android::AttachEnv();
if (regions) {
OfflineManager::ListOfflineRegionsCallback::onList(
*env, *jFileSource, *callback, *regions);
} else {
OfflineManager::ListOfflineRegionsCallback::onError(
*env, *callback, regions.error());
}
});
if (regions) {
OfflineManager::ListOfflineRegionsCallback::onList(*env, *jFileSource, *callback, *regions);
} else {
OfflineManager::ListOfflineRegionsCallback::onError(*env, *callback, regions.error());
}
});
}
void OfflineManager::createOfflineRegion(jni::JNIEnv& env_,
@@ -81,70 +81,71 @@ void OfflineManager::createOfflineRegion(jni::JNIEnv& env_,
auto globalFilesource = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, jFileSource_);
// Create region
fileSource->createOfflineRegion(definition, metadata, [
//Keep a shared ptr to a global reference of the callback and file source so they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback)),
jFileSource = std::make_shared<decltype(globalFilesource)>(std::move(globalFilesource))
](mbgl::expected<mbgl::OfflineRegion, std::exception_ptr> region) mutable {
fileSource->createOfflineRegion(
definition,
metadata,
[
// Keep a shared ptr to a global reference of the callback and file
// source so they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback)),
jFileSource = std::make_shared<decltype(globalFilesource)>(std::move(globalFilesource))](
mbgl::expected<mbgl::OfflineRegion, std::exception_ptr> region) mutable {
// Reattach, the callback comes from a different thread
android::UniqueEnv env = android::AttachEnv();
// Reattach, the callback comes from a different thread
android::UniqueEnv env = android::AttachEnv();
if (region) {
OfflineManager::CreateOfflineRegionCallback::onCreate(
*env, *jFileSource, *callback, *region
);
} else {
OfflineManager::CreateOfflineRegionCallback::onError(
*env, *callback, region.error());
}
});
if (region) {
OfflineManager::CreateOfflineRegionCallback::onCreate(*env, *jFileSource, *callback, *region);
} else {
OfflineManager::CreateOfflineRegionCallback::onError(*env, *callback, region.error());
}
});
}
void OfflineManager::mergeOfflineRegions(jni::JNIEnv& env_, const jni::Object<FileSource>& jFileSource_,
void OfflineManager::mergeOfflineRegions(jni::JNIEnv& env_,
const jni::Object<FileSource>& jFileSource_,
const jni::String& jString_,
const jni::Object<MergeOfflineRegionsCallback>& callback_) {
auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
auto globalFilesource = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, jFileSource_);
auto path = jni::Make<std::string>(env_, jString_);
fileSource->mergeOfflineRegions(path, [
//Keep a shared ptr to a global reference of the callback and file source so they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback)),
jFileSource = std::make_shared<decltype(globalFilesource)>(std::move(globalFilesource))
](mbgl::expected<mbgl::OfflineRegions, std::exception_ptr> regions) mutable {
fileSource->mergeOfflineRegions(
path,
[
// Keep a shared ptr to a global reference of the callback and file
// source so they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback)),
jFileSource = std::make_shared<decltype(globalFilesource)>(std::move(globalFilesource))](
mbgl::expected<mbgl::OfflineRegions, std::exception_ptr> regions) mutable {
// Reattach, the callback comes from a different thread
android::UniqueEnv env = android::AttachEnv();
// Reattach, the callback comes from a different thread
android::UniqueEnv env = android::AttachEnv();
if (regions) {
OfflineManager::MergeOfflineRegionsCallback::onMerge(
*env, *jFileSource, *callback, *regions);
} else {
OfflineManager::MergeOfflineRegionsCallback::onError(
*env, *callback, regions.error());
}
});
if (regions) {
OfflineManager::MergeOfflineRegionsCallback::onMerge(*env, *jFileSource, *callback, *regions);
} else {
OfflineManager::MergeOfflineRegionsCallback::onError(*env, *callback, regions.error());
}
});
}
void OfflineManager::resetDatabase(jni::JNIEnv& env_, const jni::Object<FileSourceCallback>& callback_) {
auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
fileSource->resetDatabase(
[
// Keep a shared ptr to a global reference of the callback so they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))](
std::exception_ptr exception) mutable { handleException(exception, *callback); });
fileSource->resetDatabase([
// Keep a shared ptr to a global reference of the
// callback so they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))](
std::exception_ptr exception) mutable { handleException(exception, *callback); });
}
void OfflineManager::packDatabase(jni::JNIEnv& env_, const jni::Object<FileSourceCallback>& callback_) {
auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
fileSource->packDatabase(
[
// Keep a shared ptr to a global reference of the callback so they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))](
std::exception_ptr exception) mutable { handleException(exception, *callback); });
fileSource->packDatabase([
// Keep a shared ptr to a global reference of the
// callback so they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))](
std::exception_ptr exception) mutable { handleException(exception, *callback); });
}
void OfflineManager::invalidateAmbientCache(jni::JNIEnv& env_, const jni::Object<FileSourceCallback>& callback_) {
@@ -152,7 +153,8 @@ void OfflineManager::invalidateAmbientCache(jni::JNIEnv& env_, const jni::Object
fileSource->invalidateAmbientCache(
[
// Keep a shared ptr to a global reference of the callback so they are not GC'd in the meanwhile
// Keep a shared ptr to a global reference of the callback so
// they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))](
std::exception_ptr exception) mutable { handleException(exception, *callback); });
}
@@ -160,20 +162,23 @@ void OfflineManager::invalidateAmbientCache(jni::JNIEnv& env_, const jni::Object
void OfflineManager::clearAmbientCache(jni::JNIEnv& env_, const jni::Object<FileSourceCallback>& callback_) {
auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
fileSource->clearAmbientCache(
[
// Keep a shared ptr to a global reference of the callback so they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))](
std::exception_ptr exception) mutable { handleException(exception, *callback); });
fileSource->clearAmbientCache([
// Keep a shared ptr to a global reference of the callback so
// they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))](
std::exception_ptr exception) mutable { handleException(exception, *callback); });
}
void OfflineManager::setMaximumAmbientCacheSize(jni::JNIEnv& env_, const jni::jlong size_, const jni::Object<FileSourceCallback>& callback_) {
void OfflineManager::setMaximumAmbientCacheSize(jni::JNIEnv& env_,
const jni::jlong size_,
const jni::Object<FileSourceCallback>& callback_) {
auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
fileSource->setMaximumAmbientCacheSize(
size_,
[
// Keep a shared ptr to a global reference of the callback so they are not GC'd in the meanwhile
// Keep a shared ptr to a global reference of the callback so
// they are not GC'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))](
std::exception_ptr exception) mutable { handleException(exception, *callback); });
}
@@ -185,17 +190,17 @@ void OfflineManager::runPackDatabaseAutomatically(jni::JNIEnv&, jboolean autopac
// FileSource::FileSourceCallback //
void OfflineManager::FileSourceCallback::onSuccess(jni::JNIEnv& env,
const jni::Object<OfflineManager::FileSourceCallback>& callback) {
const jni::Object<OfflineManager::FileSourceCallback>& callback) {
static auto& javaClass = jni::Class<OfflineManager::FileSourceCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void ()>(env, "onSuccess");
static auto method = javaClass.GetMethod<void()>(env, "onSuccess");
callback.Call(env, method);
}
void OfflineManager::FileSourceCallback::onError(jni::JNIEnv& env,
const jni::Object<OfflineManager::FileSourceCallback>& callback,
const jni::String& message) {
const jni::Object<OfflineManager::FileSourceCallback>& callback,
const jni::String& message) {
static auto& javaClass = jni::Class<OfflineManager::FileSourceCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
static auto method = javaClass.GetMethod<void(jni::String)>(env, "onError");
callback.Call(env, method, message);
}
@@ -207,7 +212,7 @@ void OfflineManager::registerNative(jni::JNIEnv& env) {
static auto& javaClass = jni::Class<OfflineManager>::Singleton(env);
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
jni::RegisterNativePeer<OfflineManager>(
env,
@@ -231,21 +236,23 @@ void OfflineManager::registerNative(jni::JNIEnv& env) {
// OfflineManager::ListOfflineRegionsCallback //
void OfflineManager::ListOfflineRegionsCallback::onError(jni::JNIEnv& env,
const jni::Object<OfflineManager::ListOfflineRegionsCallback>& callback,
std::exception_ptr error) {
void OfflineManager::ListOfflineRegionsCallback::onError(
jni::JNIEnv& env,
const jni::Object<OfflineManager::ListOfflineRegionsCallback>& callback,
std::exception_ptr error) {
static auto& javaClass = jni::Class<OfflineManager::ListOfflineRegionsCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
static auto method = javaClass.GetMethod<void(jni::String)>(env, "onError");
callback.Call(env, method, jni::Make<jni::String>(env, mbgl::util::toString(error)));
}
void OfflineManager::ListOfflineRegionsCallback::onList(jni::JNIEnv& env,
const jni::Object<FileSource>& jFileSource,
const jni::Object<OfflineManager::ListOfflineRegionsCallback>& callback,
mbgl::OfflineRegions& regions) {
void OfflineManager::ListOfflineRegionsCallback::onList(
jni::JNIEnv& env,
const jni::Object<FileSource>& jFileSource,
const jni::Object<OfflineManager::ListOfflineRegionsCallback>& callback,
mbgl::OfflineRegions& regions) {
static auto& javaClass = jni::Class<OfflineManager::ListOfflineRegionsCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::Array<jni::Object<OfflineRegion>>)>(env, "onList");
static auto method = javaClass.GetMethod<void(jni::Array<jni::Object<OfflineRegion>>)>(env, "onList");
std::size_t index = 0;
auto jregions = jni::Array<jni::Object<OfflineRegion>>::New(env, regions.size());
@@ -259,32 +266,35 @@ void OfflineManager::ListOfflineRegionsCallback::onList(jni::JNIEnv& env,
// OfflineManager::CreateOfflineRegionCallback //
void OfflineManager::CreateOfflineRegionCallback::onError(jni::JNIEnv& env,
const jni::Object<OfflineManager::CreateOfflineRegionCallback>& callback,
std::exception_ptr error) {
void OfflineManager::CreateOfflineRegionCallback::onError(
jni::JNIEnv& env,
const jni::Object<OfflineManager::CreateOfflineRegionCallback>& callback,
std::exception_ptr error) {
static auto& javaClass = jni::Class<OfflineManager::CreateOfflineRegionCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
static auto method = javaClass.GetMethod<void(jni::String)>(env, "onError");
callback.Call(env, method, jni::Make<jni::String>(env, mbgl::util::toString(error)));
}
void OfflineManager::CreateOfflineRegionCallback::onCreate(jni::JNIEnv& env,
const jni::Object<FileSource>& jFileSource,
const jni::Object<OfflineManager::CreateOfflineRegionCallback>& callback,
mbgl::OfflineRegion& region) {
void OfflineManager::CreateOfflineRegionCallback::onCreate(
jni::JNIEnv& env,
const jni::Object<FileSource>& jFileSource,
const jni::Object<OfflineManager::CreateOfflineRegionCallback>& callback,
mbgl::OfflineRegion& region) {
static auto& javaClass = jni::Class<OfflineManager::CreateOfflineRegionCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::Object<OfflineRegion>)>(env, "onCreate");
static auto method = javaClass.GetMethod<void(jni::Object<OfflineRegion>)>(env, "onCreate");
callback.Call(env, method, OfflineRegion::New(env, jFileSource, std::move(region)));
}
// OfflineManager::MergeOfflineRegionsCallback //
void OfflineManager::MergeOfflineRegionsCallback::onError(jni::JNIEnv& env,
const jni::Object<OfflineManager::MergeOfflineRegionsCallback>& callback,
std::exception_ptr error) {
void OfflineManager::MergeOfflineRegionsCallback::onError(
jni::JNIEnv& env,
const jni::Object<OfflineManager::MergeOfflineRegionsCallback>& callback,
std::exception_ptr error) {
static auto& javaClass = jni::Class<OfflineManager::MergeOfflineRegionsCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
static auto method = javaClass.GetMethod<void(jni::String)>(env, "onError");
callback.Call(env, method, jni::Make<jni::String>(env, mbgl::util::toString(error)));
}
@@ -294,7 +304,7 @@ void OfflineManager::MergeOfflineRegionsCallback::onMerge(jni::JNIEnv& env,
const jni::Object<MergeOfflineRegionsCallback>& callback,
mbgl::OfflineRegions& regions) {
static auto& javaClass = jni::Class<OfflineManager::MergeOfflineRegionsCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::Array<jni::Object<OfflineRegion>>)>(env, "onMerge");
static auto method = javaClass.GetMethod<void(jni::Array<jni::Object<OfflineRegion>>)>(env, "onMerge");
std::size_t index = 0;
auto jregions = jni::Array<jni::Object<OfflineRegion>>::New(env, regions.size());
@@ -313,7 +323,7 @@ void OfflineManager::putResourceWithUrl(jni::JNIEnv& env,
jlong expires,
const jni::String& eTag_,
jboolean mustRevalidate) {
auto url = jni::Make<std::string>(env, url_);
auto url = jni::Make<std::string>(env, url_);
auto data = std::make_shared<std::string>(arr.Length(env), char());
jni::GetArrayRegion(env, *arr, 0, data->size(), reinterpret_cast<jbyte*>(&(*data)[0]));
mbgl::Resource resource(mbgl::Resource::Kind::Unknown, url);

53
platform/android/MapboxGLAndroidSDK/src/cpp/offline/offline_manager.hpp
View File

@@ -16,36 +16,50 @@ namespace android {
class OfflineManager {
public:
class ListOfflineRegionsCallback {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineManager$ListOfflineRegionsCallback";}
static constexpr auto Name() {
return "com/mapbox/mapboxsdk/offline/"
"OfflineManager$ListOfflineRegionsCallback";
}
static void onError(jni::JNIEnv&, const jni::Object<OfflineManager::ListOfflineRegionsCallback>&, std::exception_ptr);
static void onError(jni::JNIEnv&,
const jni::Object<OfflineManager::ListOfflineRegionsCallback>&,
std::exception_ptr);
static void onList(jni::JNIEnv&,
const jni::Object<FileSource>&,
const jni::Object<OfflineManager::ListOfflineRegionsCallback>&,
mbgl::OfflineRegions&);
const jni::Object<FileSource>&,
const jni::Object<OfflineManager::ListOfflineRegionsCallback>&,
mbgl::OfflineRegions&);
};
class CreateOfflineRegionCallback {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineManager$CreateOfflineRegionCallback"; }
static constexpr auto Name() {
return "com/mapbox/mapboxsdk/offline/"
"OfflineManager$CreateOfflineRegionCallback";
}
static void onError(jni::JNIEnv&, const jni::Object<OfflineManager::CreateOfflineRegionCallback>&, std::exception_ptr);
static void onError(jni::JNIEnv&,
const jni::Object<OfflineManager::CreateOfflineRegionCallback>&,
std::exception_ptr);
static void onCreate(jni::JNIEnv&,
const jni::Object<FileSource>&,
const jni::Object<OfflineManager::CreateOfflineRegionCallback>&,
mbgl::OfflineRegion&);
const jni::Object<FileSource>&,
const jni::Object<OfflineManager::CreateOfflineRegionCallback>&,
mbgl::OfflineRegion&);
};
class MergeOfflineRegionsCallback {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineManager$MergeOfflineRegionsCallback";}
static constexpr auto Name() {
return "com/mapbox/mapboxsdk/offline/"
"OfflineManager$MergeOfflineRegionsCallback";
}
static void onError(jni::JNIEnv&, const jni::Object<OfflineManager::MergeOfflineRegionsCallback>&, std::exception_ptr);
static void onError(jni::JNIEnv&,
const jni::Object<OfflineManager::MergeOfflineRegionsCallback>&,
std::exception_ptr);
static void onMerge(jni::JNIEnv&,
const jni::Object<FileSource>&,
@@ -54,7 +68,10 @@ public:
};
struct FileSourceCallback {
static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineManager$FileSourceCallback";}
static constexpr auto Name() {
return "com/mapbox/mapboxsdk/offline/"
"OfflineManager$FileSourceCallback";
}
static void onSuccess(jni::JNIEnv&, const jni::Object<OfflineManager::FileSourceCallback>&);
@@ -70,7 +87,9 @@ public:
void setOfflineMapboxTileCountLimit(jni::JNIEnv&, jni::jlong limit);
void listOfflineRegions(jni::JNIEnv&, const jni::Object<FileSource>&, const jni::Object<ListOfflineRegionsCallback>& callback);
void listOfflineRegions(jni::JNIEnv&,
const jni::Object<FileSource>&,
const jni::Object<ListOfflineRegionsCallback>& callback);
void createOfflineRegion(jni::JNIEnv&,
const jni::Object<FileSource>& jFileSource_,
@@ -99,7 +118,9 @@ public:
void clearAmbientCache(jni::JNIEnv&, const jni::Object<FileSourceCallback>& callback_);
void setMaximumAmbientCacheSize(jni::JNIEnv&, const jni::jlong size, const jni::Object<FileSourceCallback>& callback_);
void setMaximumAmbientCacheSize(jni::JNIEnv&,
const jni::jlong size,
const jni::Object<FileSourceCallback>& callback_);
void runPackDatabaseAutomatically(jni::JNIEnv&, jboolean autopack);

174
platform/android/MapboxGLAndroidSDK/src/cpp/offline/offline_region.cpp
View File

@@ -16,11 +16,10 @@ namespace android {
OfflineRegion::OfflineRegion(jni::JNIEnv& env, jni::jlong offlineRegionPtr, const jni::Object<FileSource>& jFileSource)
: region(reinterpret_cast<mbgl::OfflineRegion*>(offlineRegionPtr)),
fileSource(std::static_pointer_cast<mbgl::DatabaseFileSource>(
std::shared_ptr<mbgl::FileSource>(mbgl::FileSourceManager::get()->getFileSource(
mbgl::FileSourceType::Database,
FileSource::getSharedResourceOptions(env, jFileSource),
FileSource::getSharedClientOptions(env, jFileSource))))) {
fileSource(std::static_pointer_cast<mbgl::DatabaseFileSource>(std::shared_ptr<mbgl::FileSource>(
mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::Database,
FileSource::getSharedResourceOptions(env, jFileSource),
FileSource::getSharedClientOptions(env, jFileSource))))) {
if (!fileSource) {
ThrowNew(env, jni::FindClass(env, "java/lang/IllegalStateException"), "Offline functionality is disabled.");
}
@@ -28,21 +27,20 @@ OfflineRegion::OfflineRegion(jni::JNIEnv& env, jni::jlong offlineRegionPtr, cons
OfflineRegion::~OfflineRegion() {}
void OfflineRegion::setOfflineRegionObserver(jni::JNIEnv& env_, const jni::Object<OfflineRegion::OfflineRegionObserver>& callback) {
void OfflineRegion::setOfflineRegionObserver(jni::JNIEnv& env_,
const jni::Object<OfflineRegion::OfflineRegionObserver>& callback) {
// Define the observer
class Observer : public mbgl::OfflineRegionObserver {
public:
Observer(jni::Global<jni::Object<OfflineRegion::OfflineRegionObserver>, jni::EnvAttachingDeleter> callback_)
: callback(std::move(callback_)) {
}
: callback(std::move(callback_)) {}
void statusChanged(mbgl::OfflineRegionStatus status) override {
// Reattach, the callback comes from a different thread
android::UniqueEnv env = android::AttachEnv();
static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionObserver>::Singleton(*env);
static auto method = javaClass.GetMethod<void (jni::Object<OfflineRegionStatus>)>(*env, "onStatusChanged");
static auto method = javaClass.GetMethod<void(jni::Object<OfflineRegionStatus>)>(*env, "onStatusChanged");
callback.Call(*env, method, OfflineRegionStatus::New(*env, status));
}
@@ -52,7 +50,8 @@ void OfflineRegion::setOfflineRegionObserver(jni::JNIEnv& env_, const jni::Objec
android::UniqueEnv env = android::AttachEnv();
static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionObserver>::Singleton(*env);
static auto method = javaClass.GetMethod<void (jni::Object<mbgl::android::OfflineRegionError>)>(*env, "onError");
static auto method = javaClass.GetMethod<void(jni::Object<mbgl::android::OfflineRegionError>)>(*env,
"onError");
callback.Call(*env, method, OfflineRegionError::New(*env, error));
}
@@ -62,7 +61,7 @@ void OfflineRegion::setOfflineRegionObserver(jni::JNIEnv& env_, const jni::Objec
android::UniqueEnv env = android::AttachEnv();
static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionObserver>::Singleton(*env);
static auto method = javaClass.GetMethod<void (jni::jlong)>(*env, "mapboxTileCountLimitExceeded");
static auto method = javaClass.GetMethod<void(jni::jlong)>(*env, "mapboxTileCountLimitExceeded");
callback.Call(*env, method, jlong(limit));
}
@@ -71,7 +70,8 @@ void OfflineRegion::setOfflineRegionObserver(jni::JNIEnv& env_, const jni::Objec
};
// Set the observer
fileSource->setOfflineRegionObserver(*region, std::make_unique<Observer>(jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback)));
fileSource->setOfflineRegionObserver(
*region, std::make_unique<Observer>(jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback)));
}
void OfflineRegion::setOfflineRegionDownloadState(jni::JNIEnv&, jni::jint jState) {
@@ -79,35 +79,38 @@ void OfflineRegion::setOfflineRegionDownloadState(jni::JNIEnv&, jni::jint jState
mbgl::OfflineRegionDownloadState state;
switch (jState) {
case 0:
state = mbgl::OfflineRegionDownloadState::Inactive;
break;
state = mbgl::OfflineRegionDownloadState::Inactive;
break;
case 1:
state = mbgl::OfflineRegionDownloadState::Active;
break;
state = mbgl::OfflineRegionDownloadState::Active;
break;
default:
mbgl::Log::Error(mbgl::Event::JNI, "State can only be 0 (inactive) or 1 (active).");
return;
mbgl::Log::Error(mbgl::Event::JNI, "State can only be 0 (inactive) or 1 (active).");
return;
}
fileSource->setOfflineRegionDownloadState(*region, state);
}
void OfflineRegion::getOfflineRegionStatus(jni::JNIEnv& env_, const jni::Object<OfflineRegionStatusCallback>& callback_) {
void OfflineRegion::getOfflineRegionStatus(jni::JNIEnv& env_,
const jni::Object<OfflineRegionStatusCallback>& callback_) {
auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
fileSource->getOfflineRegionStatus(*region, [
//Ensure the object is not gc'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))
](mbgl::expected<mbgl::OfflineRegionStatus, std::exception_ptr> status) mutable {
// Reattach, the callback comes from a different thread
android::UniqueEnv env = android::AttachEnv();
fileSource->getOfflineRegionStatus(
*region,
[
// Ensure the object is not gc'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))](
mbgl::expected<mbgl::OfflineRegionStatus, std::exception_ptr> status) mutable {
// Reattach, the callback comes from a different thread
android::UniqueEnv env = android::AttachEnv();
if (status) {
OfflineRegionStatusCallback::onStatus(*env, *callback, std::move(*status));
} else {
OfflineRegionStatusCallback::onError(*env, *callback, status.error());
}
});
if (status) {
OfflineRegionStatusCallback::onStatus(*env, *callback, std::move(*status));
} else {
OfflineRegionStatusCallback::onError(*env, *callback, status.error());
}
});
}
void OfflineRegion::deleteOfflineRegion(jni::JNIEnv& env_, const jni::Object<OfflineRegionDeleteCallback>& callback_) {
@@ -149,23 +152,28 @@ void OfflineRegion::invalidateOfflineRegion(jni::JNIEnv& env_,
});
}
void OfflineRegion::updateOfflineRegionMetadata(jni::JNIEnv& env_, const jni::Array<jni::jbyte>& jMetadata, const jni::Object<OfflineRegionUpdateMetadataCallback>& callback_) {
void OfflineRegion::updateOfflineRegionMetadata(jni::JNIEnv& env_,
const jni::Array<jni::jbyte>& jMetadata,
const jni::Object<OfflineRegionUpdateMetadataCallback>& callback_) {
auto metadata = OfflineRegion::metadata(env_, jMetadata);
auto globalCallback = jni::NewGlobal<jni::EnvAttachingDeleter>(env_, callback_);
fileSource->updateOfflineMetadata(region->getID(), metadata, [
//Ensure the object is not gc'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))
](mbgl::expected<mbgl::OfflineRegionMetadata, std::exception_ptr> data) mutable {
// Reattach, the callback comes from a different thread
android::UniqueEnv env = android::AttachEnv();
fileSource->updateOfflineMetadata(
region->getID(),
metadata,
[
// Ensure the object is not gc'd in the meanwhile
callback = std::make_shared<decltype(globalCallback)>(std::move(globalCallback))](
mbgl::expected<mbgl::OfflineRegionMetadata, std::exception_ptr> data) mutable {
// Reattach, the callback comes from a different thread
android::UniqueEnv env = android::AttachEnv();
if (data) {
OfflineRegionUpdateMetadataCallback::onUpdate(*env, *callback, std::move(*data));
} else {
OfflineRegionUpdateMetadataCallback::onError(*env, *callback, data.error());
}
});
if (data) {
OfflineRegionUpdateMetadataCallback::onUpdate(*env, *callback, std::move(*data));
} else {
OfflineRegionUpdateMetadataCallback::onError(*env, *callback, data.error());
}
});
}
jni::Local<jni::Object<OfflineRegion>> OfflineRegion::New(jni::JNIEnv& env,
@@ -182,10 +190,16 @@ jni::Local<jni::Object<OfflineRegion>> OfflineRegion::New(jni::JNIEnv& env,
// Create region java object
static auto& javaClass = jni::Class<OfflineRegion>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::jlong, jni::Object<FileSource>, jni::jlong, jni::Object<OfflineRegionDefinition>, jni::Array<jni::jbyte>>(env);
static auto constructor = javaClass.GetConstructor<jni::jlong,
jni::Object<FileSource>,
jni::jlong,
jni::Object<OfflineRegionDefinition>,
jni::Array<jni::jbyte>>(env);
return javaClass.New(env, constructor,
reinterpret_cast<jni::jlong>(new mbgl::OfflineRegion(std::move(region))), //Copy a region to the heap
return javaClass.New(
env,
constructor,
reinterpret_cast<jni::jlong>(new mbgl::OfflineRegion(std::move(region))), // Copy a region to the heap
jFileSource,
jni::jlong(region.getID()),
definition,
@@ -218,7 +232,7 @@ void OfflineRegion::registerNative(jni::JNIEnv& env) {
static auto& javaClass = jni::Class<OfflineRegion>::Singleton(env);
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
jni::RegisterNativePeer<OfflineRegion>(
env,
@@ -239,76 +253,84 @@ void OfflineRegion::registerNative(jni::JNIEnv& env) {
// OfflineRegionStatusCallback //
void OfflineRegion::OfflineRegionStatusCallback::onError(jni::JNIEnv& env,
const jni::Object<OfflineRegion::OfflineRegionStatusCallback>& callback,
std::exception_ptr error) {
void OfflineRegion::OfflineRegionStatusCallback::onError(
jni::JNIEnv& env,
const jni::Object<OfflineRegion::OfflineRegionStatusCallback>& callback,
std::exception_ptr error) {
static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionStatusCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void(jni::String)>(env, "onError");
callback.Call(env, method, jni::Make<jni::String>(env, mbgl::util::toString(error)));
}
void OfflineRegion::OfflineRegionStatusCallback::onStatus(jni::JNIEnv& env,
const jni::Object<OfflineRegion::OfflineRegionStatusCallback>& callback,
std::optional<mbgl::OfflineRegionStatus> status) {
void OfflineRegion::OfflineRegionStatusCallback::onStatus(
jni::JNIEnv& env,
const jni::Object<OfflineRegion::OfflineRegionStatusCallback>& callback,
std::optional<mbgl::OfflineRegionStatus> status) {
static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionStatusCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::Object<OfflineRegionStatus>)>(env, "onStatus");
static auto method = javaClass.GetMethod<void(jni::Object<OfflineRegionStatus>)>(env, "onStatus");
callback.Call(env, method, OfflineRegionStatus::New(env, std::move(*status)));
}
// OfflineRegionDeleteCallback //
void OfflineRegion::OfflineRegionDeleteCallback::onError(jni::JNIEnv& env,
const jni::Object<OfflineRegion::OfflineRegionDeleteCallback>& callback,
std::exception_ptr error) {
void OfflineRegion::OfflineRegionDeleteCallback::onError(
jni::JNIEnv& env,
const jni::Object<OfflineRegion::OfflineRegionDeleteCallback>& callback,
std::exception_ptr error) {
static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionDeleteCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
static auto method = javaClass.GetMethod<void(jni::String)>(env, "onError");
callback.Call(env, method, jni::Make<jni::String>(env, mbgl::util::toString(error)));
}
void OfflineRegion::OfflineRegionDeleteCallback::onDelete(jni::JNIEnv& env, const jni::Object<OfflineRegion::OfflineRegionDeleteCallback>& callback) {
void OfflineRegion::OfflineRegionDeleteCallback::onDelete(
jni::JNIEnv& env, const jni::Object<OfflineRegion::OfflineRegionDeleteCallback>& callback) {
// Trigger callback
static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionDeleteCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void ()>(env, "onDelete");
static auto method = javaClass.GetMethod<void()>(env, "onDelete");
callback.Call(env, method);
}
// OfflineRegionUpdateMetadataCallback //
void OfflineRegion::OfflineRegionUpdateMetadataCallback::onError(jni::JNIEnv& env,
const jni::Object<OfflineRegion::OfflineRegionUpdateMetadataCallback>& callback,
std::exception_ptr error) {
void OfflineRegion::OfflineRegionUpdateMetadataCallback::onError(
jni::JNIEnv& env,
const jni::Object<OfflineRegion::OfflineRegionUpdateMetadataCallback>& callback,
std::exception_ptr error) {
static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionUpdateMetadataCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
static auto method = javaClass.GetMethod<void(jni::String)>(env, "onError");
callback.Call(env, method, jni::Make<jni::String>(env, mbgl::util::toString(error)));
}
void OfflineRegion::OfflineRegionUpdateMetadataCallback::onUpdate(jni::JNIEnv& env,
const jni::Object<OfflineRegion::OfflineRegionUpdateMetadataCallback>& callback,
std::optional<mbgl::OfflineRegionMetadata> metadata) {
void OfflineRegion::OfflineRegionUpdateMetadataCallback::onUpdate(
jni::JNIEnv& env,
const jni::Object<OfflineRegion::OfflineRegionUpdateMetadataCallback>& callback,
std::optional<mbgl::OfflineRegionMetadata> metadata) {
static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionUpdateMetadataCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::Array<jni::jbyte>)>(env, "onUpdate");
static auto method = javaClass.GetMethod<void(jni::Array<jni::jbyte>)>(env, "onUpdate");
callback.Call(env, method, OfflineRegion::metadata(env, std::move(*metadata)));
}
// OfflineRegionInvalidateCallback //
void OfflineRegion::OfflineRegionInvalidateCallback::onError(jni::JNIEnv& env,
const jni::Object<OfflineRegion::OfflineRegionInvalidateCallback>& callback,
std::exception_ptr error) {
void OfflineRegion::OfflineRegionInvalidateCallback::onError(
jni::JNIEnv& env,
const jni::Object<OfflineRegion::OfflineRegionInvalidateCallback>& callback,
std::exception_ptr error) {
static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionInvalidateCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void (jni::String)>(env, "onError");
static auto method = javaClass.GetMethod<void(jni::String)>(env, "onError");
callback.Call(env, method, jni::Make<jni::String>(env, mbgl::util::toString(error)));
}
void OfflineRegion::OfflineRegionInvalidateCallback::onInvalidate(jni::JNIEnv& env, const jni::Object<OfflineRegion::OfflineRegionInvalidateCallback>& callback) {
void OfflineRegion::OfflineRegionInvalidateCallback::onInvalidate(
jni::JNIEnv& env, const jni::Object<OfflineRegion::OfflineRegionInvalidateCallback>& callback) {
static auto& javaClass = jni::Class<OfflineRegion::OfflineRegionInvalidateCallback>::Singleton(env);
static auto method = javaClass.GetMethod<void ()>(env, "onInvalidate");
static auto method = javaClass.GetMethod<void()>(env, "onInvalidate");
callback.Call(env, method);
}

41
platform/android/MapboxGLAndroidSDK/src/cpp/offline/offline_region.hpp
View File

@@ -14,23 +14,32 @@ class OfflineRegion {
public:
class OfflineRegionObserver {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegion$OfflineRegionObserver"; };
static constexpr auto Name() {
return "com/mapbox/mapboxsdk/offline/"
"OfflineRegion$OfflineRegionObserver";
};
};
class OfflineRegionStatusCallback {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegion$OfflineRegionStatusCallback"; };
static constexpr auto Name() {
return "com/mapbox/mapboxsdk/offline/"
"OfflineRegion$OfflineRegionStatusCallback";
};
static void onError(jni::JNIEnv&, const jni::Object<OfflineRegionStatusCallback>&, std::exception_ptr);
static void onStatus(jni::JNIEnv&,
const jni::Object<OfflineRegionStatusCallback>&,
std::optional<mbgl::OfflineRegionStatus>);
const jni::Object<OfflineRegionStatusCallback>&,
std::optional<mbgl::OfflineRegionStatus>);
};
class OfflineRegionDeleteCallback {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegion$OfflineRegionDeleteCallback"; };
static constexpr auto Name() {
return "com/mapbox/mapboxsdk/offline/"
"OfflineRegion$OfflineRegionDeleteCallback";
};
static void onError(jni::JNIEnv&, const jni::Object<OfflineRegionDeleteCallback>&, std::exception_ptr);
@@ -39,7 +48,10 @@ public:
class OfflineRegionInvalidateCallback {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegion$OfflineRegionInvalidateCallback"; };
static constexpr auto Name() {
return "com/mapbox/mapboxsdk/offline/"
"OfflineRegion$OfflineRegionInvalidateCallback";
};
static void onError(jni::JNIEnv&, const jni::Object<OfflineRegionInvalidateCallback>&, std::exception_ptr);
@@ -48,13 +60,16 @@ public:
class OfflineRegionUpdateMetadataCallback {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegion$OfflineRegionUpdateMetadataCallback"; };
static constexpr auto Name() {
return "com/mapbox/mapboxsdk/offline/"
"OfflineRegion$OfflineRegionUpdateMetadataCallback";
};
static void onError(jni::JNIEnv&, const jni::Object<OfflineRegionUpdateMetadataCallback>&, std::exception_ptr);
static void onUpdate(jni::JNIEnv&,
const jni::Object<OfflineRegionUpdateMetadataCallback>&,
std::optional<mbgl::OfflineRegionMetadata>);
const jni::Object<OfflineRegionUpdateMetadataCallback>&,
std::optional<mbgl::OfflineRegionMetadata>);
};
static constexpr auto Name() { return "com/mapbox/mapboxsdk/offline/OfflineRegion"; };
@@ -73,9 +88,13 @@ public:
void invalidateOfflineRegion(jni::JNIEnv&, const jni::Object<OfflineRegionInvalidateCallback>&);
void updateOfflineRegionMetadata(jni::JNIEnv&, const jni::Array<jni::jbyte>&, const jni::Object<OfflineRegionUpdateMetadataCallback>&);
void updateOfflineRegionMetadata(jni::JNIEnv&,
const jni::Array<jni::jbyte>&,
const jni::Object<OfflineRegionUpdateMetadataCallback>&);
static jni::Local<jni::Object<OfflineRegion>> New(jni::JNIEnv&, const jni::Object<FileSource>&, mbgl::OfflineRegion);
static jni::Local<jni::Object<OfflineRegion>> New(jni::JNIEnv&,
const jni::Object<FileSource>&,
mbgl::OfflineRegion);
static jni::Local<jni::Array<jni::jbyte>> metadata(jni::JNIEnv&, mbgl::OfflineRegionMetadata);

96
platform/android/MapboxGLAndroidSDK/src/cpp/offline/offline_region_definition.cpp
View File

@@ -14,12 +14,14 @@ void OfflineRegionDefinition::registerNative(jni::JNIEnv& env) {
jni::Class<OfflineRegionDefinition>::Singleton(env);
}
mbgl::OfflineRegionDefinition OfflineRegionDefinition::getDefinition(JNIEnv& env,
const jni::Object<OfflineRegionDefinition>& jDefinition) {
mbgl::OfflineRegionDefinition OfflineRegionDefinition::getDefinition(
JNIEnv& env, const jni::Object<OfflineRegionDefinition>& jDefinition) {
if (jDefinition.IsInstanceOf(env, jni::Class<OfflineTilePyramidRegionDefinition>::Singleton(env))) {
return OfflineTilePyramidRegionDefinition::getDefinition(env, jni::Cast(env, jni::Class<OfflineTilePyramidRegionDefinition>::Singleton(env), jDefinition));
return OfflineTilePyramidRegionDefinition::getDefinition(
env, jni::Cast(env, jni::Class<OfflineTilePyramidRegionDefinition>::Singleton(env), jDefinition));
} else if (jDefinition.IsInstanceOf(env, jni::Class<OfflineGeometryRegionDefinition>::Singleton(env))) {
return OfflineGeometryRegionDefinition::getDefinition(env, jni::Cast(env, jni::Class<OfflineGeometryRegionDefinition>::Singleton(env), jDefinition));
return OfflineGeometryRegionDefinition::getDefinition(
env, jni::Cast(env, jni::Class<OfflineGeometryRegionDefinition>::Singleton(env), jDefinition));
}
throw std::runtime_error("Unknown offline region definition java class");
@@ -27,20 +29,28 @@ mbgl::OfflineRegionDefinition OfflineRegionDefinition::getDefinition(JNIEnv& env
// OfflineTilePyramidRegionDefinition //
jni::Local<jni::Object<OfflineRegionDefinition>> OfflineTilePyramidRegionDefinition::New(jni::JNIEnv& env, const mbgl::OfflineTilePyramidRegionDefinition& definition) {
jni::Local<jni::Object<OfflineRegionDefinition>> OfflineTilePyramidRegionDefinition::New(
jni::JNIEnv& env, const mbgl::OfflineTilePyramidRegionDefinition& definition) {
static auto& javaClass = jni::Class<OfflineTilePyramidRegionDefinition>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::String, jni::Object<LatLngBounds>, jni::jdouble, jni::jdouble, jni::jfloat, jni::jboolean>(env);
static auto constructor = javaClass.GetConstructor<jni::String,
jni::Object<LatLngBounds>,
jni::jdouble,
jni::jdouble,
jni::jfloat,
jni::jboolean>(env);
return javaClass.New(env, constructor,
jni::Make<jni::String>(env, definition.styleURL),
LatLngBounds::New(env, definition.bounds),
definition.minZoom,
definition.maxZoom,
definition.pixelRatio,
jni::jboolean(definition.includeIdeographs));
return javaClass.New(env,
constructor,
jni::Make<jni::String>(env, definition.styleURL),
LatLngBounds::New(env, definition.bounds),
definition.minZoom,
definition.maxZoom,
definition.pixelRatio,
jni::jboolean(definition.includeIdeographs));
}
mbgl::OfflineTilePyramidRegionDefinition OfflineTilePyramidRegionDefinition::getDefinition(jni::JNIEnv& env, const jni::Object<OfflineTilePyramidRegionDefinition>& jDefinition) {
mbgl::OfflineTilePyramidRegionDefinition OfflineTilePyramidRegionDefinition::getDefinition(
jni::JNIEnv& env, const jni::Object<OfflineTilePyramidRegionDefinition>& jDefinition) {
// Field references
static auto& javaClass = jni::Class<OfflineTilePyramidRegionDefinition>::Singleton(env);
static auto styleURLF = javaClass.GetField<jni::String>(env, "styleURL");
@@ -48,16 +58,14 @@ mbgl::OfflineTilePyramidRegionDefinition OfflineTilePyramidRegionDefinition::get
static auto minZoomF = javaClass.GetField<jni::jdouble>(env, "minZoom");
static auto maxZoomF = javaClass.GetField<jni::jdouble>(env, "maxZoom");
static auto pixelRatioF = javaClass.GetField<jni::jfloat>(env, "pixelRatio");
static auto includeIdeographsF = javaClass.GetField<jni::jboolean >(env, "includeIdeographs");
static auto includeIdeographsF = javaClass.GetField<jni::jboolean>(env, "includeIdeographs");
return mbgl::OfflineTilePyramidRegionDefinition(
jni::Make<std::string>(env, jDefinition.Get(env, styleURLF)),
LatLngBounds::getLatLngBounds(env, jDefinition.Get(env, boundsF)),
jDefinition.Get(env, minZoomF),
jDefinition.Get(env, maxZoomF),
jDefinition.Get(env, pixelRatioF),
jDefinition.Get(env, includeIdeographsF)
);
return mbgl::OfflineTilePyramidRegionDefinition(jni::Make<std::string>(env, jDefinition.Get(env, styleURLF)),
LatLngBounds::getLatLngBounds(env, jDefinition.Get(env, boundsF)),
jDefinition.Get(env, minZoomF),
jDefinition.Get(env, maxZoomF),
jDefinition.Get(env, pixelRatioF),
jDefinition.Get(env, includeIdeographsF));
}
void OfflineTilePyramidRegionDefinition::registerNative(jni::JNIEnv& env) {
@@ -66,20 +74,28 @@ void OfflineTilePyramidRegionDefinition::registerNative(jni::JNIEnv& env) {
// OfflineGeometryRegionDefinition //
jni::Local<jni::Object<OfflineRegionDefinition>> OfflineGeometryRegionDefinition::New(jni::JNIEnv& env, const mbgl::OfflineGeometryRegionDefinition& definition) {
jni::Local<jni::Object<OfflineRegionDefinition>> OfflineGeometryRegionDefinition::New(
jni::JNIEnv& env, const mbgl::OfflineGeometryRegionDefinition& definition) {
static auto& javaClass = jni::Class<OfflineGeometryRegionDefinition>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::String, jni::Object<geojson::Geometry>, jni::jdouble, jni::jdouble, jni::jfloat, jni::jboolean>(env);
static auto constructor = javaClass.GetConstructor<jni::String,
jni::Object<geojson::Geometry>,
jni::jdouble,
jni::jdouble,
jni::jfloat,
jni::jboolean>(env);
return javaClass.New(env, constructor,
jni::Make<jni::String>(env, definition.styleURL),
geojson::Geometry::New(env, definition.geometry),
definition.minZoom,
definition.maxZoom,
definition.pixelRatio,
jni::jboolean(definition.includeIdeographs));
return javaClass.New(env,
constructor,
jni::Make<jni::String>(env, definition.styleURL),
geojson::Geometry::New(env, definition.geometry),
definition.minZoom,
definition.maxZoom,
definition.pixelRatio,
jni::jboolean(definition.includeIdeographs));
}
mbgl::OfflineGeometryRegionDefinition OfflineGeometryRegionDefinition::getDefinition(jni::JNIEnv& env, const jni::Object<OfflineGeometryRegionDefinition>& jDefinition) {
mbgl::OfflineGeometryRegionDefinition OfflineGeometryRegionDefinition::getDefinition(
jni::JNIEnv& env, const jni::Object<OfflineGeometryRegionDefinition>& jDefinition) {
// Field references
static auto& javaClass = jni::Class<OfflineGeometryRegionDefinition>::Singleton(env);
static auto styleURLF = javaClass.GetField<jni::String>(env, "styleURL");
@@ -89,14 +105,12 @@ mbgl::OfflineGeometryRegionDefinition OfflineGeometryRegionDefinition::getDefini
static auto pixelRatioF = javaClass.GetField<jni::jfloat>(env, "pixelRatio");
static auto includeIdeographsF = javaClass.GetField<jni::jboolean>(env, "includeIdeographs");
return mbgl::OfflineGeometryRegionDefinition(
jni::Make<std::string>(env, jDefinition.Get(env, styleURLF)),
geojson::Geometry::convert(env, jDefinition.Get(env, geometryF)),
jDefinition.Get(env, minZoomF),
jDefinition.Get(env, maxZoomF),
jDefinition.Get(env, pixelRatioF),
jDefinition.Get(env, includeIdeographsF)
);
return mbgl::OfflineGeometryRegionDefinition(jni::Make<std::string>(env, jDefinition.Get(env, styleURLF)),
geojson::Geometry::convert(env, jDefinition.Get(env, geometryF)),
jDefinition.Get(env, minZoomF),
jDefinition.Get(env, maxZoomF),
jDefinition.Get(env, pixelRatioF),
jDefinition.Get(env, includeIdeographsF));
}
void OfflineGeometryRegionDefinition::registerNative(jni::JNIEnv& env) {

20
platform/android/MapboxGLAndroidSDK/src/cpp/offline/offline_region_definition.hpp
View File

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

8
platform/android/MapboxGLAndroidSDK/src/cpp/offline/offline_region_error.cpp
View File

@@ -4,10 +4,9 @@ namespace mbgl {
namespace android {
jni::Local<jni::Object<OfflineRegionError>> OfflineRegionError::New(jni::JNIEnv& env, mbgl::Response::Error error) {
// Handle the value of reason independently of the underlying int value
std::string reason;
switch(error.reason) {
switch (error.reason) {
case mbgl::Response::Error::Reason::Success:
reason = "REASON_SUCCESS";
break;
@@ -31,9 +30,8 @@ jni::Local<jni::Object<OfflineRegionError>> OfflineRegionError::New(jni::JNIEnv&
static auto& javaClass = jni::Class<OfflineRegionError>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::String, jni::String>(env);
return javaClass.New(env, constructor,
jni::Make<jni::String>(env, reason),
jni::Make<jni::String>(env, error.message));
return javaClass.New(
env, constructor, jni::Make<jni::String>(env, reason), jni::Make<jni::String>(env, error.message));
}
void OfflineRegionError::registerNative(jni::JNIEnv& env) {

24
platform/android/MapboxGLAndroidSDK/src/cpp/offline/offline_region_status.cpp
View File

@@ -3,11 +3,11 @@
namespace mbgl {
namespace android {
jni::Local<jni::Object<OfflineRegionStatus>> OfflineRegionStatus::New(jni::JNIEnv& env, mbgl::OfflineRegionStatus status) {
jni::Local<jni::Object<OfflineRegionStatus>> OfflineRegionStatus::New(jni::JNIEnv& env,
mbgl::OfflineRegionStatus status) {
// Convert to jint
jint downloadState;
switch(status.downloadState) {
switch (status.downloadState) {
case mbgl::OfflineRegionDownloadState::Inactive:
downloadState = 0;
break;
@@ -19,15 +19,15 @@ jni::Local<jni::Object<OfflineRegionStatus>> OfflineRegionStatus::New(jni::JNIEn
// Create java object
static auto& javaClass = jni::Class<OfflineRegionStatus>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jint, jlong, jlong, jlong, jlong, jlong, jboolean>(env);
return javaClass.New(env, constructor,
downloadState,
jlong(status.completedResourceCount),
jlong(status.completedResourceSize),
jlong(status.completedTileCount),
jlong(status.completedTileSize),
jlong(status.requiredResourceCount),
jboolean(status.requiredResourceCountIsPrecise)
);
return javaClass.New(env,
constructor,
downloadState,
jlong(status.completedResourceCount),
jlong(status.completedResourceSize),
jlong(status.completedTileCount),
jlong(status.completedTileSize),
jlong(status.requiredResourceCount),
jboolean(status.requiredResourceCountIsPrecise));
}
void OfflineRegionStatus::registerNative(jni::JNIEnv& env) {

45
platform/android/MapboxGLAndroidSDK/src/cpp/snapshotter/map_snapshot.cpp
View File

@@ -9,10 +9,9 @@ namespace mbgl {
namespace android {
MapSnapshot::MapSnapshot(float pixelRatio_, MapSnapshot::PointForFn pointForFn_, MapSnapshot::LatLngForFn latLngForFn_)
: pixelRatio(pixelRatio_)
, pointForFn(std::move(pointForFn_))
, latLngForFn(std::move(latLngForFn_)) {
}
: pixelRatio(pixelRatio_),
pointForFn(std::move(pointForFn_)),
latLngForFn(std::move(latLngForFn_)) {}
MapSnapshot::~MapSnapshot() = default;
@@ -28,20 +27,26 @@ jni::Local<jni::Object<LatLng>> MapSnapshot::latLngForPixel(jni::JNIEnv& env, jn
// Static methods //
jni::Local<jni::Object<MapSnapshot>> MapSnapshot::New(JNIEnv& env,
PremultipliedImage&& image,
float pixelRatio,
std::vector<std::string> attributions,
bool showLogo,
mbgl::MapSnapshotter::PointForFn pointForFn,
mbgl::MapSnapshotter::LatLngForFn latLngForFn) {
PremultipliedImage&& image,
float pixelRatio,
std::vector<std::string> attributions,
bool showLogo,
mbgl::MapSnapshotter::PointForFn pointForFn,
mbgl::MapSnapshotter::LatLngForFn latLngForFn) {
// Create the bitmap
auto bitmap = Bitmap::CreateBitmap(env, std::move(image));
// Create the Mapsnapshot peers
static auto& javaClass = jni::Class<MapSnapshot>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::jlong, jni::Object<Bitmap>, jni::Array<jni::String>, jni::jboolean>(env);
static auto constructor =
javaClass.GetConstructor<jni::jlong, jni::Object<Bitmap>, jni::Array<jni::String>, jni::jboolean>(env);
auto nativePeer = std::make_unique<MapSnapshot>(pixelRatio, pointForFn, latLngForFn);
return javaClass.New(env, constructor, reinterpret_cast<jlong>(nativePeer.release()), bitmap, conversion::toArray(env, attributions), (jni::jboolean) showLogo);
return javaClass.New(env,
constructor,
reinterpret_cast<jlong>(nativePeer.release()),
bitmap,
conversion::toArray(env, attributions),
(jni::jboolean)showLogo);
}
void MapSnapshot::registerNative(jni::JNIEnv& env) {
@@ -51,14 +56,14 @@ void MapSnapshot::registerNative(jni::JNIEnv& env) {
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
// Register the peer
jni::RegisterNativePeer<MapSnapshot>(env, javaClass,
"nativePtr",
std::make_unique<MapSnapshot, JNIEnv&>,
"initialize",
"finalize",
METHOD(&MapSnapshot::latLngForPixel, "latLngForPixel"),
METHOD(&MapSnapshot::pixelForLatLng, "pixelForLatLng")
);
jni::RegisterNativePeer<MapSnapshot>(env,
javaClass,
"nativePtr",
std::make_unique<MapSnapshot, JNIEnv&>,
"initialize",
"finalize",
METHOD(&MapSnapshot::latLngForPixel, "latLngForPixel"),
METHOD(&MapSnapshot::pixelForLatLng, "pixelForLatLng"));
}
} // namespace android

15
platform/android/MapboxGLAndroidSDK/src/cpp/snapshotter/map_snapshot.hpp
View File

@@ -15,7 +15,6 @@ namespace android {
class MapSnapshot {
public:
using PointForFn = mbgl::MapSnapshotter::PointForFn;
using LatLngForFn = mbgl::MapSnapshotter::LatLngForFn;
@@ -24,14 +23,14 @@ public:
static void registerNative(jni::JNIEnv&);
static jni::Local<jni::Object<MapSnapshot>> New(JNIEnv& env,
PremultipliedImage&& image,
float pixelRatio,
std::vector<std::string> attributions,
bool showLogo,
PointForFn pointForFn,
LatLngForFn latLngForFn);
PremultipliedImage&& image,
float pixelRatio,
std::vector<std::string> attributions,
bool showLogo,
PointForFn pointForFn,
LatLngForFn latLngForFn);
MapSnapshot(jni::JNIEnv&) {};
MapSnapshot(jni::JNIEnv&){};
MapSnapshot(float pixelRatio, PointForFn, LatLngForFn);
~MapSnapshot();

19
platform/android/MapboxGLAndroidSDK/src/cpp/snapshotter/map_snapshotter.cpp
View File

@@ -25,9 +25,8 @@ MapSnapshotter::MapSnapshotter(jni::JNIEnv& _env,
const jni::Object<CameraPosition>& position,
jni::jboolean _showLogo,
const jni::String& _localIdeographFontFamily)
: javaPeer(_env, _obj)
, pixelRatio(_pixelRatio) {
: javaPeer(_env, _obj),
pixelRatio(_pixelRatio) {
// Get a reference to the JavaVM for callbacks
if (_env.GetJavaVM(&vm) < 0) {
_env.ExceptionDescribe();
@@ -37,7 +36,7 @@ MapSnapshotter::MapSnapshotter(jni::JNIEnv& _env,
weakScheduler = mbgl::Scheduler::GetCurrent()->makeWeakPtr();
jFileSource = FileSource::getNativePeer(_env, _jFileSource);
auto size = mbgl::Size { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
auto size = mbgl::Size{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
showLogo = _showLogo;
@@ -48,7 +47,8 @@ MapSnapshotter::MapSnapshotter(jni::JNIEnv& _env,
mbgl::android::FileSource::getSharedResourceOptions(_env, _jFileSource),
mbgl::android::FileSource::getSharedClientOptions(_env, _jFileSource),
*this,
_localIdeographFontFamily ? jni::Make<std::string>(_env, _localIdeographFontFamily) : std::optional<std::string>{});
_localIdeographFontFamily ? jni::Make<std::string>(_env, _localIdeographFontFamily)
: std::optional<std::string>{});
if (position) {
snapshotter->setCameraOptions(CameraPosition::getCameraOptions(_env, position, pixelRatio));
@@ -91,17 +91,18 @@ void MapSnapshotter::start(JNIEnv& env) {
if (err) {
// error handler callback
static auto onSnapshotFailed = javaClass.GetMethod<void (jni::String)>(*_env, "onSnapshotFailed");
static auto onSnapshotFailed = javaClass.GetMethod<void(jni::String)>(*_env, "onSnapshotFailed");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onSnapshotFailed, jni::Make<jni::String>(*_env, util::toString(err)));
}
} else {
// Create the wrapper
auto mapSnapshot = android::MapSnapshot::New(*_env, std::move(image), pixelRatio, attributions, showLogo, pointForFn, latLngForFn);
auto mapSnapshot = android::MapSnapshot::New(
*_env, std::move(image), pixelRatio, attributions, showLogo, pointForFn, latLngForFn);
// invoke callback
static auto onSnapshotReady = javaClass.GetMethod<void (jni::Object<MapSnapshot>)>(*_env, "onSnapshotReady");
static auto onSnapshotReady = javaClass.GetMethod<void(jni::Object<MapSnapshot>)>(*_env, "onSnapshotReady");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onSnapshotReady, mapSnapshot);
@@ -127,7 +128,7 @@ void MapSnapshotter::setStyleJson(JNIEnv& env, const jni::String& styleJSON) {
}
void MapSnapshotter::setSize(JNIEnv&, jni::jint width, jni::jint height) {
auto size = mbgl::Size { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
auto size = mbgl::Size{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
snapshotter->setSize(size);
}

5
platform/android/MapboxGLAndroidSDK/src/cpp/snapshotter/map_snapshotter.hpp
View File

@@ -19,7 +19,6 @@ namespace android {
class MapSnapshotter final : public mbgl::MapSnapshotterObserver {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/snapshotter/MapSnapshotter"; };
static void registerNative(jni::JNIEnv&);
@@ -69,13 +68,13 @@ public:
private:
MBGL_STORE_THREAD(tid);
JavaVM *vm = nullptr;
JavaVM* vm = nullptr;
jni::WeakReference<jni::Object<MapSnapshotter>, jni::EnvAttachingDeleter> javaPeer;
float pixelRatio;
bool showLogo;
FileSource *jFileSource;
FileSource* jFileSource;
void activateFilesource(JNIEnv&);
void deactivateFilesource(JNIEnv&);
bool activatedFilesource = false;

35
platform/android/MapboxGLAndroidSDK/src/cpp/style/android_conversion.hpp
View File

@@ -17,25 +17,18 @@ namespace conversion {
template <>
class ConversionTraits<mbgl::android::Value> {
public:
static bool isUndefined(const mbgl::android::Value& value) {
return value.isNull();
}
static bool isUndefined(const mbgl::android::Value& value) { return value.isNull(); }
static bool isArray(const mbgl::android::Value& value) {
return value.isArray();
}
static bool isArray(const mbgl::android::Value& value) { return value.isArray(); }
static bool isObject(const mbgl::android::Value& value) {
return value.isObject();
}
static bool isObject(const mbgl::android::Value& value) { return value.isObject(); }
static std::size_t arrayLength(const mbgl::android::Value& value) {
return value.getLength();;
return value.getLength();
;
}
static mbgl::android::Value arrayMember(const mbgl::android::Value& value, std::size_t i) {
return value.get(i);
}
static mbgl::android::Value arrayMember(const mbgl::android::Value& value, std::size_t i) { return value.get(i); }
static std::optional<mbgl::android::Value> objectMember(const mbgl::android::Value& value, const char* key) {
mbgl::android::Value member = value.get(key);
@@ -51,7 +44,7 @@ public:
assert(value.isObject());
mbgl::android::Value keys = value.keyArray();
std::size_t length = arrayLength(keys);
for(std::size_t i = 0; i < length; ++i){
for (std::size_t i = 0; i < length; ++i) {
const auto k = keys.get(i).toString();
auto v = value.get(k.c_str());
std::optional<Error> result = fn(k, std::move(v));
@@ -99,19 +92,19 @@ public:
if (value.isNull()) {
return {};
} else if (value.isBool()) {
return { value.toBool() };
return {value.toBool()};
} else if (value.isString()) {
return { value.toString() };
return {value.toString()};
} else if (value.isNumber()) {
return { value.toDouble() };
return {value.toDouble()};
} else {
return {};
}
}
static std::optional<GeoJSON> toGeoJSON(const mbgl::android::Value &value, Error &error) {
static std::optional<GeoJSON> toGeoJSON(const mbgl::android::Value& value, Error& error) {
if (value.isNull()) {
error = { "no json data found" };
error = {"no json data found"};
return {};
}
@@ -138,8 +131,8 @@ public:
}
};
template <class T, class...Args>
std::optional<T> convert(mbgl::android::Value&& value, Error& error, Args&&...args) {
template <class T, class... Args>
std::optional<T> convert(mbgl::android::Value&& value, Error& error, Args&&... args) {
return convert<T>(Convertible(std::move(value)), error, std::forward<Args>(args)...);
}

12
platform/android/MapboxGLAndroidSDK/src/cpp/style/conversion/filter.cpp
View File

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

15
platform/android/MapboxGLAndroidSDK/src/cpp/style/conversion/position.cpp
View File

@@ -4,21 +4,24 @@ namespace mbgl {
namespace android {
namespace conversion {
Result<jni::Local<jni::Object<Position>>> Converter<jni::Local<jni::Object<Position>>, mbgl::style::Position>::operator()(jni::JNIEnv &env, const mbgl::style::Position &value) const {
Result<jni::Local<jni::Object<Position>>>
Converter<jni::Local<jni::Object<Position>>, mbgl::style::Position>::operator()(
jni::JNIEnv &env, const mbgl::style::Position &value) const {
std::array<float, 3> cartPosition = value.getSpherical();
return Position::fromPosition(env, cartPosition[0], cartPosition[1], cartPosition[2]);
}
Result<mbgl::style::Position> Converter<mbgl::style::Position, jni::Object<Position>>::operator()(jni::JNIEnv &env, const jni::Object<Position> &value) const {
Result<mbgl::style::Position> Converter<mbgl::style::Position, jni::Object<Position>>::operator()(
jni::JNIEnv &env, const jni::Object<Position> &value) const {
float radialCoordinate = Position::getRadialCoordinate(env, value);
float azimuthalAngle = Position::getAzimuthalAngle(env, value);
float polarAngle = Position::getPolarAngle(env, value);
std::array<float, 3> cartPosition {{radialCoordinate, azimuthalAngle, polarAngle}};
std::array<float, 3> cartPosition{{radialCoordinate, azimuthalAngle, polarAngle}};
mbgl::style::Position position{};
position.set(cartPosition);
return position;
}
}
}
}
} // namespace conversion
} // namespace android
} // namespace mbgl

6
platform/android/MapboxGLAndroidSDK/src/cpp/style/conversion/position.hpp
View File

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

3
platform/android/MapboxGLAndroidSDK/src/cpp/style/conversion/property_expression.hpp
View File

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

6
platform/android/MapboxGLAndroidSDK/src/cpp/style/conversion/property_value.hpp
View File

@@ -17,7 +17,8 @@ namespace conversion {
template <typename T>
class PropertyValueEvaluator {
public:
PropertyValueEvaluator(jni::JNIEnv& _env) : env(_env) {}
PropertyValueEvaluator(jni::JNIEnv& _env)
: env(_env) {}
jni::Local<jni::Object<>> operator()(const mbgl::style::Undefined) const {
return jni::Local<jni::Object<>>(env, nullptr);
@@ -51,7 +52,8 @@ struct Converter<jni::Local<jni::Object<>>, mbgl::style::PropertyValue<T>> {
*/
template <>
struct Converter<jni::Local<jni::Object<>>, mbgl::style::ColorRampPropertyValue> {
Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const mbgl::style::ColorRampPropertyValue& value) const {
Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env,
const mbgl::style::ColorRampPropertyValue& value) const {
PropertyValueEvaluator<mbgl::style::ColorRampPropertyValue> evaluator(env);
return std::move(*convert<jni::Local<jni::Object<>>>(env, value.evaluate(evaluator)));
}

16
platform/android/MapboxGLAndroidSDK/src/cpp/style/conversion/transition_options.cpp
View File

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

11
platform/android/MapboxGLAndroidSDK/src/cpp/style/conversion/transition_options.hpp
View File

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

8
platform/android/MapboxGLAndroidSDK/src/cpp/style/conversion/url_or_tileset.cpp
View File

@@ -20,11 +20,11 @@ variant<std::string, Tileset> convertURLOrTileset(mbgl::android::Value&& value)
if (!tileset) {
throw std::logic_error(error.message);
}
return { *tileset };
return {*tileset};
} else {
return { *toString(convertible) };
return {*toString(convertible)};
}
}
}
}
} // namespace android
} // namespace mbgl

2
platform/android/MapboxGLAndroidSDK/src/cpp/style/conversion/url_or_tileset.hpp
View File

@@ -13,4 +13,4 @@ namespace android {
variant<std::string, Tileset> convertURLOrTileset(mbgl::android::Value&& value);
}
}
} // namespace mbgl

6
platform/android/MapboxGLAndroidSDK/src/cpp/style/formatted.cpp
View File

@@ -24,7 +24,7 @@ jni::Local<jni::Object<Formatted>> Formatted::New(jni::JNIEnv& env, const style:
if (section.fontScale) {
double fontScale = section.fontScale.value();
static auto method = formattedSectionClass.GetMethod<void (jni::Number)>(env, "setFontScale");
static auto method = formattedSectionClass.GetMethod<void(jni::Number)>(env, "setFontScale");
formattedSection.Call(env, method, jni::Box(env, fontScale));
}
@@ -33,14 +33,14 @@ jni::Local<jni::Object<Formatted>> Formatted::New(jni::JNIEnv& env, const style:
for (std::size_t j = 0; j < section.fontStack.value().size(); j++) {
fontStack.Set(env, j, jni::Make<jni::String>(env, section.fontStack.value().at(j)));
}
static auto method = formattedSectionClass.GetMethod<void (jni::Array<jni::String>)>(env, "setFontStack");
static auto method = formattedSectionClass.GetMethod<void(jni::Array<jni::String>)>(env, "setFontStack");
formattedSection.Call(env, method, fontStack);
}
if (section.textColor) {
using namespace mbgl::android::conversion;
auto textColor = std::move(*convert<jni::Local<jni::Object<>>>(env, *section.textColor));
static auto method = formattedSectionClass.GetMethod<void (jni::Object<>)>(env, "setTextColor");
static auto method = formattedSectionClass.GetMethod<void(jni::Object<>)>(env, "setTextColor");
formattedSection.Call(env, method, textColor);
}

19
platform/android/MapboxGLAndroidSDK/src/cpp/style/formatted.hpp
View File

@@ -6,18 +6,17 @@
#include <mbgl/style/expression/formatted.hpp>
namespace mbgl {
namespace android {
namespace android {
using SuperTag = jni::ObjectTag;
class Formatted : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/types/Formatted"; };
using SuperTag = jni::ObjectTag;
class Formatted : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/types/Formatted"; };
static jni::Local<jni::Object<Formatted>>
New(jni::JNIEnv&, const style::expression::Formatted &value);
static jni::Local<jni::Object<Formatted>> New(jni::JNIEnv &, const style::expression::Formatted &value);
static void registerNative(jni::JNIEnv &);
};
static void registerNative(jni::JNIEnv &);
};
} // namespace android
} // namespace android
} // namespace mbgl

216
platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/background_layer.cpp
View File

@@ -12,136 +12,136 @@
namespace mbgl {
namespace android {
inline mbgl::style::BackgroundLayer& toBackgroundLayer(mbgl::style::Layer& layer) {
return static_cast<mbgl::style::BackgroundLayer&>(layer);
}
inline mbgl::style::BackgroundLayer& toBackgroundLayer(mbgl::style::Layer& layer) {
return static_cast<mbgl::style::BackgroundLayer&>(layer);
}
/**
* Creates an owning peer object (for layers not attached to the map) from the JVM side
*/
BackgroundLayer::BackgroundLayer(jni::JNIEnv& env, jni::String& layerId)
: Layer(std::make_unique<mbgl::style::BackgroundLayer>(jni::Make<std::string>(env, layerId))) {
}
/**
* Creates an owning peer object (for layers not attached to the map) from the JVM side
*/
BackgroundLayer::BackgroundLayer(jni::JNIEnv& env, jni::String& layerId)
: Layer(std::make_unique<mbgl::style::BackgroundLayer>(jni::Make<std::string>(env, layerId))) {}
/**
* Creates a non-owning peer object (for layers currently attached to the map)
*/
BackgroundLayer::BackgroundLayer(mbgl::style::BackgroundLayer& coreLayer)
: Layer(coreLayer) {
}
/**
* Creates a non-owning peer object (for layers currently attached to the map)
*/
BackgroundLayer::BackgroundLayer(mbgl::style::BackgroundLayer& coreLayer)
: Layer(coreLayer) {}
/**
* Creates an owning peer object (for layers not attached to the map)
*/
BackgroundLayer::BackgroundLayer(std::unique_ptr<mbgl::style::BackgroundLayer> coreLayer)
: Layer(std::move(coreLayer)) {
}
/**
* Creates an owning peer object (for layers not attached to the map)
*/
BackgroundLayer::BackgroundLayer(std::unique_ptr<mbgl::style::BackgroundLayer> coreLayer)
: Layer(std::move(coreLayer)) {}
BackgroundLayer::~BackgroundLayer() = default;
BackgroundLayer::~BackgroundLayer() = default;
// Property getters
// Property getters
jni::Local<jni::Object<>> BackgroundLayer::getBackgroundColor(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toBackgroundLayer(layer).getBackgroundColor()));
}
jni::Local<jni::Object<>> BackgroundLayer::getBackgroundColor(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toBackgroundLayer(layer).getBackgroundColor()));
}
jni::Local<jni::Object<TransitionOptions>> BackgroundLayer::getBackgroundColorTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toBackgroundLayer(layer).getBackgroundColorTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> BackgroundLayer::getBackgroundColorTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toBackgroundLayer(layer).getBackgroundColorTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void BackgroundLayer::setBackgroundColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toBackgroundLayer(layer).setBackgroundColorTransition(options);
}
void BackgroundLayer::setBackgroundColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toBackgroundLayer(layer).setBackgroundColorTransition(options);
}
jni::Local<jni::Object<>> BackgroundLayer::getBackgroundPattern(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toBackgroundLayer(layer).getBackgroundPattern()));
}
jni::Local<jni::Object<>> BackgroundLayer::getBackgroundPattern(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toBackgroundLayer(layer).getBackgroundPattern()));
}
jni::Local<jni::Object<TransitionOptions>> BackgroundLayer::getBackgroundPatternTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toBackgroundLayer(layer).getBackgroundPatternTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> BackgroundLayer::getBackgroundPatternTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toBackgroundLayer(layer).getBackgroundPatternTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void BackgroundLayer::setBackgroundPatternTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toBackgroundLayer(layer).setBackgroundPatternTransition(options);
}
void BackgroundLayer::setBackgroundPatternTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toBackgroundLayer(layer).setBackgroundPatternTransition(options);
}
jni::Local<jni::Object<>> BackgroundLayer::getBackgroundOpacity(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toBackgroundLayer(layer).getBackgroundOpacity()));
}
jni::Local<jni::Object<>> BackgroundLayer::getBackgroundOpacity(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toBackgroundLayer(layer).getBackgroundOpacity()));
}
jni::Local<jni::Object<TransitionOptions>> BackgroundLayer::getBackgroundOpacityTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toBackgroundLayer(layer).getBackgroundOpacityTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> BackgroundLayer::getBackgroundOpacityTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toBackgroundLayer(layer).getBackgroundOpacityTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void BackgroundLayer::setBackgroundOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toBackgroundLayer(layer).setBackgroundOpacityTransition(options);
}
void BackgroundLayer::setBackgroundOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toBackgroundLayer(layer).setBackgroundOpacityTransition(options);
}
// BackgroundJavaLayerPeerFactory
// BackgroundJavaLayerPeerFactory
BackgroundJavaLayerPeerFactory::~BackgroundJavaLayerPeerFactory() = default;
BackgroundJavaLayerPeerFactory::~BackgroundJavaLayerPeerFactory() = default;
namespace {
jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
static auto& javaClass = jni::Class<BackgroundLayer>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
}
} // namespace
namespace {
jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
static auto& javaClass = jni::Class<BackgroundLayer>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
}
} // namespace
jni::Local<jni::Object<Layer>> BackgroundJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
mbgl::style::Layer& layer) {
assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
return createJavaPeer(env, new BackgroundLayer(toBackgroundLayer(layer)));
}
jni::Local<jni::Object<Layer>> BackgroundJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::style::Layer& layer) {
assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
return createJavaPeer(env, new BackgroundLayer(toBackgroundLayer(layer)));
}
jni::Local<jni::Object<Layer>> BackgroundJavaLayerPeerFactory::createJavaLayerPeer(
jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
return createJavaPeer(env,
new BackgroundLayer(std::unique_ptr<mbgl::style::BackgroundLayer>(
static_cast<mbgl::style::BackgroundLayer*>(layer.release()))));
}
jni::Local<jni::Object<Layer>> BackgroundJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
return createJavaPeer(env, new BackgroundLayer(std::unique_ptr<mbgl::style::BackgroundLayer>(static_cast<mbgl::style::BackgroundLayer*>(layer.release()))));
}
void BackgroundJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
// Lookup the class
static auto& javaClass = jni::Class<BackgroundLayer>::Singleton(env);
void BackgroundJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
// Lookup the class
static auto& javaClass = jni::Class<BackgroundLayer>::Singleton(env);
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
// Register the peer
jni::RegisterNativePeer<BackgroundLayer>(
env,
javaClass,
"nativePtr",
jni::MakePeer<BackgroundLayer, jni::String&>,
"initialize",
"finalize",
METHOD(&BackgroundLayer::getBackgroundColorTransition, "nativeGetBackgroundColorTransition"),
METHOD(&BackgroundLayer::setBackgroundColorTransition, "nativeSetBackgroundColorTransition"),
METHOD(&BackgroundLayer::getBackgroundColor, "nativeGetBackgroundColor"),
METHOD(&BackgroundLayer::getBackgroundPatternTransition, "nativeGetBackgroundPatternTransition"),
METHOD(&BackgroundLayer::setBackgroundPatternTransition, "nativeSetBackgroundPatternTransition"),
METHOD(&BackgroundLayer::getBackgroundPattern, "nativeGetBackgroundPattern"),
METHOD(&BackgroundLayer::getBackgroundOpacityTransition, "nativeGetBackgroundOpacityTransition"),
METHOD(&BackgroundLayer::setBackgroundOpacityTransition, "nativeSetBackgroundOpacityTransition"),
METHOD(&BackgroundLayer::getBackgroundOpacity, "nativeGetBackgroundOpacity"));
}
// Register the peer
jni::RegisterNativePeer<BackgroundLayer>(
env,
javaClass,
"nativePtr",
jni::MakePeer<BackgroundLayer, jni::String&>,
"initialize",
"finalize",
METHOD(&BackgroundLayer::getBackgroundColorTransition, "nativeGetBackgroundColorTransition"),
METHOD(&BackgroundLayer::setBackgroundColorTransition, "nativeSetBackgroundColorTransition"),
METHOD(&BackgroundLayer::getBackgroundColor, "nativeGetBackgroundColor"),
METHOD(&BackgroundLayer::getBackgroundPatternTransition, "nativeGetBackgroundPatternTransition"),
METHOD(&BackgroundLayer::setBackgroundPatternTransition, "nativeSetBackgroundPatternTransition"),
METHOD(&BackgroundLayer::getBackgroundPattern, "nativeGetBackgroundPattern"),
METHOD(&BackgroundLayer::getBackgroundOpacityTransition, "nativeGetBackgroundOpacityTransition"),
METHOD(&BackgroundLayer::setBackgroundOpacityTransition, "nativeSetBackgroundOpacityTransition"),
METHOD(&BackgroundLayer::getBackgroundOpacity, "nativeGetBackgroundOpacity"));
}
} // namespace android
} // namespace mbgl

4
platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/background_layer.hpp
View File

@@ -40,7 +40,7 @@ public:
}; // class BackgroundLayer
class BackgroundJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::BackgroundLayerFactory {
class BackgroundJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::BackgroundLayerFactory {
public:
~BackgroundJavaLayerPeerFactory() override;
@@ -52,7 +52,7 @@ public:
LayerFactory* getLayerFactory() final { return this; }
}; // class BackgroundJavaLayerPeerFactory
}; // class BackgroundJavaLayerPeerFactory
} // namespace android
} // namespace mbgl

437
platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/circle_layer.cpp
View File

@@ -12,265 +12,266 @@
namespace mbgl {
namespace android {
inline mbgl::style::CircleLayer& toCircleLayer(mbgl::style::Layer& layer) {
return static_cast<mbgl::style::CircleLayer&>(layer);
}
inline mbgl::style::CircleLayer& toCircleLayer(mbgl::style::Layer& layer) {
return static_cast<mbgl::style::CircleLayer&>(layer);
}
/**
* Creates an owning peer object (for layers not attached to the map) from the JVM side
*/
CircleLayer::CircleLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
: Layer(std::make_unique<mbgl::style::CircleLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
}
/**
* Creates an owning peer object (for layers not attached to the map) from the JVM side
*/
CircleLayer::CircleLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
: Layer(std::make_unique<mbgl::style::CircleLayer>(jni::Make<std::string>(env, layerId),
jni::Make<std::string>(env, sourceId))) {}
/**
* Creates a non-owning peer object (for layers currently attached to the map)
*/
CircleLayer::CircleLayer(mbgl::style::CircleLayer& coreLayer)
: Layer(coreLayer) {
}
/**
* Creates a non-owning peer object (for layers currently attached to the map)
*/
CircleLayer::CircleLayer(mbgl::style::CircleLayer& coreLayer)
: Layer(coreLayer) {}
/**
* Creates an owning peer object (for layers not attached to the map)
*/
CircleLayer::CircleLayer(std::unique_ptr<mbgl::style::CircleLayer> coreLayer)
: Layer(std::move(coreLayer)) {
}
/**
* Creates an owning peer object (for layers not attached to the map)
*/
CircleLayer::CircleLayer(std::unique_ptr<mbgl::style::CircleLayer> coreLayer)
: Layer(std::move(coreLayer)) {}
CircleLayer::~CircleLayer() = default;
CircleLayer::~CircleLayer() = default;
// Property getters
// Property getters
jni::Local<jni::Object<>> CircleLayer::getCircleSortKey(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleSortKey()));
}
jni::Local<jni::Object<>> CircleLayer::getCircleSortKey(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleSortKey()));
}
jni::Local<jni::Object<>> CircleLayer::getCircleRadius(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleRadius()));
}
jni::Local<jni::Object<>> CircleLayer::getCircleRadius(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleRadius()));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleRadiusTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleRadiusTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleRadiusTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleRadiusTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void CircleLayer::setCircleRadiusTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleRadiusTransition(options);
}
void CircleLayer::setCircleRadiusTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleRadiusTransition(options);
}
jni::Local<jni::Object<>> CircleLayer::getCircleColor(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleColor()));
}
jni::Local<jni::Object<>> CircleLayer::getCircleColor(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleColor()));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleColorTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleColorTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleColorTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleColorTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void CircleLayer::setCircleColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleColorTransition(options);
}
void CircleLayer::setCircleColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleColorTransition(options);
}
jni::Local<jni::Object<>> CircleLayer::getCircleBlur(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleBlur()));
}
jni::Local<jni::Object<>> CircleLayer::getCircleBlur(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleBlur()));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleBlurTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleBlurTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleBlurTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleBlurTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void CircleLayer::setCircleBlurTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleBlurTransition(options);
}
void CircleLayer::setCircleBlurTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleBlurTransition(options);
}
jni::Local<jni::Object<>> CircleLayer::getCircleOpacity(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleOpacity()));
}
jni::Local<jni::Object<>> CircleLayer::getCircleOpacity(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleOpacity()));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleOpacityTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleOpacityTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleOpacityTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleOpacityTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void CircleLayer::setCircleOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleOpacityTransition(options);
}
void CircleLayer::setCircleOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleOpacityTransition(options);
}
jni::Local<jni::Object<>> CircleLayer::getCircleTranslate(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleTranslate()));
}
jni::Local<jni::Object<>> CircleLayer::getCircleTranslate(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleTranslate()));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleTranslateTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleTranslateTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleTranslateTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleTranslateTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void CircleLayer::setCircleTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleTranslateTransition(options);
}
void CircleLayer::setCircleTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleTranslateTransition(options);
}
jni::Local<jni::Object<>> CircleLayer::getCircleTranslateAnchor(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleTranslateAnchor()));
}
jni::Local<jni::Object<>> CircleLayer::getCircleTranslateAnchor(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleTranslateAnchor()));
}
jni::Local<jni::Object<>> CircleLayer::getCirclePitchScale(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCirclePitchScale()));
}
jni::Local<jni::Object<>> CircleLayer::getCirclePitchScale(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCirclePitchScale()));
}
jni::Local<jni::Object<>> CircleLayer::getCirclePitchAlignment(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCirclePitchAlignment()));
}
jni::Local<jni::Object<>> CircleLayer::getCirclePitchAlignment(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCirclePitchAlignment()));
}
jni::Local<jni::Object<>> CircleLayer::getCircleStrokeWidth(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleStrokeWidth()));
}
jni::Local<jni::Object<>> CircleLayer::getCircleStrokeWidth(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleStrokeWidth()));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleStrokeWidthTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleStrokeWidthTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleStrokeWidthTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleStrokeWidthTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void CircleLayer::setCircleStrokeWidthTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleStrokeWidthTransition(options);
}
void CircleLayer::setCircleStrokeWidthTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleStrokeWidthTransition(options);
}
jni::Local<jni::Object<>> CircleLayer::getCircleStrokeColor(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleStrokeColor()));
}
jni::Local<jni::Object<>> CircleLayer::getCircleStrokeColor(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleStrokeColor()));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleStrokeColorTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleStrokeColorTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleStrokeColorTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleStrokeColorTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void CircleLayer::setCircleStrokeColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleStrokeColorTransition(options);
}
void CircleLayer::setCircleStrokeColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleStrokeColorTransition(options);
}
jni::Local<jni::Object<>> CircleLayer::getCircleStrokeOpacity(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleStrokeOpacity()));
}
jni::Local<jni::Object<>> CircleLayer::getCircleStrokeOpacity(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toCircleLayer(layer).getCircleStrokeOpacity()));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleStrokeOpacityTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleStrokeOpacityTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> CircleLayer::getCircleStrokeOpacityTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toCircleLayer(layer).getCircleStrokeOpacityTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void CircleLayer::setCircleStrokeOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleStrokeOpacityTransition(options);
}
void CircleLayer::setCircleStrokeOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toCircleLayer(layer).setCircleStrokeOpacityTransition(options);
}
// CircleJavaLayerPeerFactory
// CircleJavaLayerPeerFactory
CircleJavaLayerPeerFactory::~CircleJavaLayerPeerFactory() = default;
CircleJavaLayerPeerFactory::~CircleJavaLayerPeerFactory() = default;
namespace {
jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
static auto& javaClass = jni::Class<CircleLayer>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
}
} // namespace
namespace {
jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
static auto& javaClass = jni::Class<CircleLayer>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
}
} // namespace
jni::Local<jni::Object<Layer>> CircleJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
mbgl::style::Layer& layer) {
assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
return createJavaPeer(env, new CircleLayer(toCircleLayer(layer)));
}
jni::Local<jni::Object<Layer>> CircleJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::style::Layer& layer) {
assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
return createJavaPeer(env, new CircleLayer(toCircleLayer(layer)));
}
jni::Local<jni::Object<Layer>> CircleJavaLayerPeerFactory::createJavaLayerPeer(
jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
return createJavaPeer(env,
new CircleLayer(std::unique_ptr<mbgl::style::CircleLayer>(
static_cast<mbgl::style::CircleLayer*>(layer.release()))));
}
jni::Local<jni::Object<Layer>> CircleJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
return createJavaPeer(env, new CircleLayer(std::unique_ptr<mbgl::style::CircleLayer>(static_cast<mbgl::style::CircleLayer*>(layer.release()))));
}
void CircleJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
// Lookup the class
static auto& javaClass = jni::Class<CircleLayer>::Singleton(env);
void CircleJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
// Lookup the class
static auto& javaClass = jni::Class<CircleLayer>::Singleton(env);
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
// Register the peer
jni::RegisterNativePeer<CircleLayer>(
env,
javaClass,
"nativePtr",
jni::MakePeer<CircleLayer, jni::String&, jni::String&>,
"initialize",
"finalize",
METHOD(&CircleLayer::getCircleSortKey, "nativeGetCircleSortKey"),
METHOD(&CircleLayer::getCircleRadiusTransition, "nativeGetCircleRadiusTransition"),
METHOD(&CircleLayer::setCircleRadiusTransition, "nativeSetCircleRadiusTransition"),
METHOD(&CircleLayer::getCircleRadius, "nativeGetCircleRadius"),
METHOD(&CircleLayer::getCircleColorTransition, "nativeGetCircleColorTransition"),
METHOD(&CircleLayer::setCircleColorTransition, "nativeSetCircleColorTransition"),
METHOD(&CircleLayer::getCircleColor, "nativeGetCircleColor"),
METHOD(&CircleLayer::getCircleBlurTransition, "nativeGetCircleBlurTransition"),
METHOD(&CircleLayer::setCircleBlurTransition, "nativeSetCircleBlurTransition"),
METHOD(&CircleLayer::getCircleBlur, "nativeGetCircleBlur"),
METHOD(&CircleLayer::getCircleOpacityTransition, "nativeGetCircleOpacityTransition"),
METHOD(&CircleLayer::setCircleOpacityTransition, "nativeSetCircleOpacityTransition"),
METHOD(&CircleLayer::getCircleOpacity, "nativeGetCircleOpacity"),
METHOD(&CircleLayer::getCircleTranslateTransition, "nativeGetCircleTranslateTransition"),
METHOD(&CircleLayer::setCircleTranslateTransition, "nativeSetCircleTranslateTransition"),
METHOD(&CircleLayer::getCircleTranslate, "nativeGetCircleTranslate"),
METHOD(&CircleLayer::getCircleTranslateAnchor, "nativeGetCircleTranslateAnchor"),
METHOD(&CircleLayer::getCirclePitchScale, "nativeGetCirclePitchScale"),
METHOD(&CircleLayer::getCirclePitchAlignment, "nativeGetCirclePitchAlignment"),
METHOD(&CircleLayer::getCircleStrokeWidthTransition, "nativeGetCircleStrokeWidthTransition"),
METHOD(&CircleLayer::setCircleStrokeWidthTransition, "nativeSetCircleStrokeWidthTransition"),
METHOD(&CircleLayer::getCircleStrokeWidth, "nativeGetCircleStrokeWidth"),
METHOD(&CircleLayer::getCircleStrokeColorTransition, "nativeGetCircleStrokeColorTransition"),
METHOD(&CircleLayer::setCircleStrokeColorTransition, "nativeSetCircleStrokeColorTransition"),
METHOD(&CircleLayer::getCircleStrokeColor, "nativeGetCircleStrokeColor"),
METHOD(&CircleLayer::getCircleStrokeOpacityTransition, "nativeGetCircleStrokeOpacityTransition"),
METHOD(&CircleLayer::setCircleStrokeOpacityTransition, "nativeSetCircleStrokeOpacityTransition"),
METHOD(&CircleLayer::getCircleStrokeOpacity, "nativeGetCircleStrokeOpacity"));
}
// Register the peer
jni::RegisterNativePeer<CircleLayer>(
env,
javaClass,
"nativePtr",
jni::MakePeer<CircleLayer, jni::String&, jni::String&>,
"initialize",
"finalize",
METHOD(&CircleLayer::getCircleSortKey, "nativeGetCircleSortKey"),
METHOD(&CircleLayer::getCircleRadiusTransition, "nativeGetCircleRadiusTransition"),
METHOD(&CircleLayer::setCircleRadiusTransition, "nativeSetCircleRadiusTransition"),
METHOD(&CircleLayer::getCircleRadius, "nativeGetCircleRadius"),
METHOD(&CircleLayer::getCircleColorTransition, "nativeGetCircleColorTransition"),
METHOD(&CircleLayer::setCircleColorTransition, "nativeSetCircleColorTransition"),
METHOD(&CircleLayer::getCircleColor, "nativeGetCircleColor"),
METHOD(&CircleLayer::getCircleBlurTransition, "nativeGetCircleBlurTransition"),
METHOD(&CircleLayer::setCircleBlurTransition, "nativeSetCircleBlurTransition"),
METHOD(&CircleLayer::getCircleBlur, "nativeGetCircleBlur"),
METHOD(&CircleLayer::getCircleOpacityTransition, "nativeGetCircleOpacityTransition"),
METHOD(&CircleLayer::setCircleOpacityTransition, "nativeSetCircleOpacityTransition"),
METHOD(&CircleLayer::getCircleOpacity, "nativeGetCircleOpacity"),
METHOD(&CircleLayer::getCircleTranslateTransition, "nativeGetCircleTranslateTransition"),
METHOD(&CircleLayer::setCircleTranslateTransition, "nativeSetCircleTranslateTransition"),
METHOD(&CircleLayer::getCircleTranslate, "nativeGetCircleTranslate"),
METHOD(&CircleLayer::getCircleTranslateAnchor, "nativeGetCircleTranslateAnchor"),
METHOD(&CircleLayer::getCirclePitchScale, "nativeGetCirclePitchScale"),
METHOD(&CircleLayer::getCirclePitchAlignment, "nativeGetCirclePitchAlignment"),
METHOD(&CircleLayer::getCircleStrokeWidthTransition, "nativeGetCircleStrokeWidthTransition"),
METHOD(&CircleLayer::setCircleStrokeWidthTransition, "nativeSetCircleStrokeWidthTransition"),
METHOD(&CircleLayer::getCircleStrokeWidth, "nativeGetCircleStrokeWidth"),
METHOD(&CircleLayer::getCircleStrokeColorTransition, "nativeGetCircleStrokeColorTransition"),
METHOD(&CircleLayer::setCircleStrokeColorTransition, "nativeSetCircleStrokeColorTransition"),
METHOD(&CircleLayer::getCircleStrokeColor, "nativeGetCircleStrokeColor"),
METHOD(&CircleLayer::getCircleStrokeOpacityTransition, "nativeGetCircleStrokeOpacityTransition"),
METHOD(&CircleLayer::setCircleStrokeOpacityTransition, "nativeSetCircleStrokeOpacityTransition"),
METHOD(&CircleLayer::getCircleStrokeOpacity, "nativeGetCircleStrokeOpacity"));
}
} // namespace android
} // namespace mbgl

4
platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/circle_layer.hpp
View File

@@ -68,7 +68,7 @@ public:
}; // class CircleLayer
class CircleJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::CircleLayerFactory {
class CircleJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::CircleLayerFactory {
public:
~CircleJavaLayerPeerFactory() override;
@@ -80,7 +80,7 @@ public:
LayerFactory* getLayerFactory() final { return this; }
}; // class CircleJavaLayerPeerFactory
}; // class CircleJavaLayerPeerFactory
} // namespace android
} // namespace mbgl

78
platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/custom_layer.cpp
View File

@@ -7,55 +7,55 @@
namespace mbgl {
namespace android {
CustomLayer::CustomLayer(jni::JNIEnv& env, const jni::String& layerId, jni::jlong host)
: Layer(std::make_unique<mbgl::style::CustomLayer>(
jni::Make<std::string>(env, layerId),
std::unique_ptr<mbgl::style::CustomLayerHost>(reinterpret_cast<mbgl::style::CustomLayerHost*>(host)))
) {
}
CustomLayer::CustomLayer(jni::JNIEnv& env, const jni::String& layerId, jni::jlong host)
: Layer(std::make_unique<mbgl::style::CustomLayer>(
jni::Make<std::string>(env, layerId),
std::unique_ptr<mbgl::style::CustomLayerHost>(reinterpret_cast<mbgl::style::CustomLayerHost*>(host)))) {}
CustomLayer::CustomLayer(mbgl::style::CustomLayer& coreLayer) : Layer(coreLayer) {}
CustomLayer::CustomLayer(mbgl::style::CustomLayer& coreLayer)
: Layer(coreLayer) {}
CustomLayer::CustomLayer(std::unique_ptr<mbgl::style::CustomLayer> coreLayer) : Layer(std::move(coreLayer)) {}
CustomLayer::CustomLayer(std::unique_ptr<mbgl::style::CustomLayer> coreLayer)
: Layer(std::move(coreLayer)) {}
CustomLayer::~CustomLayer() = default;
CustomLayer::~CustomLayer() = default;
namespace {
jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
static auto& javaClass = jni::Class<CustomLayer>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
}
}
namespace {
jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
static auto& javaClass = jni::Class<CustomLayer>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
}
} // namespace
CustomJavaLayerPeerFactory::~CustomJavaLayerPeerFactory() = default;
CustomJavaLayerPeerFactory::~CustomJavaLayerPeerFactory() = default;
jni::Local<jni::Object<Layer>> CustomJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
mbgl::style::Layer& layer) {
return createJavaPeer(env, new CustomLayer(static_cast<mbgl::style::CustomLayer&>(layer)));
}
jni::Local<jni::Object<Layer>> CustomJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
mbgl::style::Layer& layer) {
return createJavaPeer(env, new CustomLayer(static_cast<mbgl::style::CustomLayer&>(layer)));
}
jni::Local<jni::Object<Layer>> CustomJavaLayerPeerFactory::createJavaLayerPeer(
jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
return createJavaPeer(env,
new CustomLayer(std::unique_ptr<mbgl::style::CustomLayer>(
static_cast<mbgl::style::CustomLayer*>(layer.release()))));
}
jni::Local<jni::Object<Layer>> CustomJavaLayerPeerFactory::createJavaLayerPeer(
jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
return createJavaPeer(env,
new CustomLayer(std::unique_ptr<mbgl::style::CustomLayer>(
static_cast<mbgl::style::CustomLayer*>(layer.release()))));
}
void CustomJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
// Lookup the class
static auto& javaClass = jni::Class<CustomLayer>::Singleton(env);
void CustomJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
// Lookup the class
static auto& javaClass = jni::Class<CustomLayer>::Singleton(env);
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
// Register the peer
jni::RegisterNativePeer<CustomLayer>(env,
javaClass,
"nativePtr",
jni::MakePeer<CustomLayer, const jni::String&, jni::jlong>,
"initialize",
"finalize");
}
// Register the peer
jni::RegisterNativePeer<CustomLayer>(env,
javaClass,
"nativePtr",
jni::MakePeer<CustomLayer, const jni::String&, jni::jlong>,
"initialize",
"finalize");
}
} // namespace android
} // namespace mbgl

4
platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/custom_layer.hpp
View File

@@ -23,7 +23,7 @@ public:
jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv&);
}; // class CustomLayer
class CustomJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::CustomLayerFactory {
class CustomJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::CustomLayerFactory {
public:
~CustomJavaLayerPeerFactory() override;
@@ -35,7 +35,7 @@ public:
LayerFactory* getLayerFactory() final { return this; }
}; // class CustomJavaLayerPeerFactory
}; // class CustomJavaLayerPeerFactory
} // namespace android
} // namespace mbgl

347
platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/fill_extrusion_layer.cpp
View File

@@ -12,211 +12,214 @@
namespace mbgl {
namespace android {
inline mbgl::style::FillExtrusionLayer& toFillExtrusionLayer(mbgl::style::Layer& layer) {
return static_cast<mbgl::style::FillExtrusionLayer&>(layer);
}
inline mbgl::style::FillExtrusionLayer& toFillExtrusionLayer(mbgl::style::Layer& layer) {
return static_cast<mbgl::style::FillExtrusionLayer&>(layer);
}
/**
* Creates an owning peer object (for layers not attached to the map) from the JVM side
*/
FillExtrusionLayer::FillExtrusionLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
: Layer(std::make_unique<mbgl::style::FillExtrusionLayer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
}
/**
* Creates an owning peer object (for layers not attached to the map) from the JVM side
*/
FillExtrusionLayer::FillExtrusionLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
: Layer(std::make_unique<mbgl::style::FillExtrusionLayer>(jni::Make<std::string>(env, layerId),
jni::Make<std::string>(env, sourceId))) {}
/**
* Creates a non-owning peer object (for layers currently attached to the map)
*/
FillExtrusionLayer::FillExtrusionLayer(mbgl::style::FillExtrusionLayer& coreLayer)
: Layer(coreLayer) {
}
/**
* Creates a non-owning peer object (for layers currently attached to the map)
*/
FillExtrusionLayer::FillExtrusionLayer(mbgl::style::FillExtrusionLayer& coreLayer)
: Layer(coreLayer) {}
/**
* Creates an owning peer object (for layers not attached to the map)
*/
FillExtrusionLayer::FillExtrusionLayer(std::unique_ptr<mbgl::style::FillExtrusionLayer> coreLayer)
: Layer(std::move(coreLayer)) {
}
/**
* Creates an owning peer object (for layers not attached to the map)
*/
FillExtrusionLayer::FillExtrusionLayer(std::unique_ptr<mbgl::style::FillExtrusionLayer> coreLayer)
: Layer(std::move(coreLayer)) {}
FillExtrusionLayer::~FillExtrusionLayer() = default;
FillExtrusionLayer::~FillExtrusionLayer() = default;
// Property getters
// Property getters
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionOpacity(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionOpacity()));
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionOpacity(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionOpacity()));
}
jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionOpacityTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionOpacityTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionOpacityTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionOpacityTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void FillExtrusionLayer::setFillExtrusionOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toFillExtrusionLayer(layer).setFillExtrusionOpacityTransition(options);
}
void FillExtrusionLayer::setFillExtrusionOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toFillExtrusionLayer(layer).setFillExtrusionOpacityTransition(options);
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionColor(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionColor()));
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionColor(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionColor()));
}
jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionColorTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionColorTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionColorTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionColorTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void FillExtrusionLayer::setFillExtrusionColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toFillExtrusionLayer(layer).setFillExtrusionColorTransition(options);
}
void FillExtrusionLayer::setFillExtrusionColorTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toFillExtrusionLayer(layer).setFillExtrusionColorTransition(options);
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionTranslate(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionTranslate()));
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionTranslate(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionTranslate()));
}
jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionTranslateTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionTranslateTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionTranslateTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionTranslateTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void FillExtrusionLayer::setFillExtrusionTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toFillExtrusionLayer(layer).setFillExtrusionTranslateTransition(options);
}
void FillExtrusionLayer::setFillExtrusionTranslateTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toFillExtrusionLayer(layer).setFillExtrusionTranslateTransition(options);
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionTranslateAnchor(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionTranslateAnchor()));
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionTranslateAnchor(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(
*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionTranslateAnchor()));
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionPattern(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionPattern()));
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionPattern(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionPattern()));
}
jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionPatternTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionPatternTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionPatternTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionPatternTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void FillExtrusionLayer::setFillExtrusionPatternTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toFillExtrusionLayer(layer).setFillExtrusionPatternTransition(options);
}
void FillExtrusionLayer::setFillExtrusionPatternTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toFillExtrusionLayer(layer).setFillExtrusionPatternTransition(options);
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionHeight(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionHeight()));
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionHeight(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionHeight()));
}
jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionHeightTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionHeightTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionHeightTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionHeightTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void FillExtrusionLayer::setFillExtrusionHeightTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toFillExtrusionLayer(layer).setFillExtrusionHeightTransition(options);
}
void FillExtrusionLayer::setFillExtrusionHeightTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toFillExtrusionLayer(layer).setFillExtrusionHeightTransition(options);
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionBase(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionBase()));
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionBase(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionBase()));
}
jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionBaseTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionBaseTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
jni::Local<jni::Object<TransitionOptions>> FillExtrusionLayer::getFillExtrusionBaseTransition(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
mbgl::style::TransitionOptions options = toFillExtrusionLayer(layer).getFillExtrusionBaseTransition();
return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
}
void FillExtrusionLayer::setFillExtrusionBaseTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toFillExtrusionLayer(layer).setFillExtrusionBaseTransition(options);
}
void FillExtrusionLayer::setFillExtrusionBaseTransition(jni::JNIEnv&, jlong duration, jlong delay) {
mbgl::style::TransitionOptions options;
options.duration.emplace(mbgl::Milliseconds(duration));
options.delay.emplace(mbgl::Milliseconds(delay));
toFillExtrusionLayer(layer).setFillExtrusionBaseTransition(options);
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionVerticalGradient(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionVerticalGradient()));
}
jni::Local<jni::Object<>> FillExtrusionLayer::getFillExtrusionVerticalGradient(jni::JNIEnv& env) {
using namespace mbgl::android::conversion;
return std::move(
*convert<jni::Local<jni::Object<>>>(env, toFillExtrusionLayer(layer).getFillExtrusionVerticalGradient()));
}
// FillExtrusionJavaLayerPeerFactory
// FillExtrusionJavaLayerPeerFactory
FillExtrusionJavaLayerPeerFactory::~FillExtrusionJavaLayerPeerFactory() = default;
FillExtrusionJavaLayerPeerFactory::~FillExtrusionJavaLayerPeerFactory() = default;
namespace {
jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
static auto& javaClass = jni::Class<FillExtrusionLayer>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
}
} // namespace
namespace {
jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
static auto& javaClass = jni::Class<FillExtrusionLayer>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
}
} // namespace
jni::Local<jni::Object<Layer>> FillExtrusionJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
mbgl::style::Layer& layer) {
assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
return createJavaPeer(env, new FillExtrusionLayer(toFillExtrusionLayer(layer)));
}
jni::Local<jni::Object<Layer>> FillExtrusionJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::style::Layer& layer) {
assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
return createJavaPeer(env, new FillExtrusionLayer(toFillExtrusionLayer(layer)));
}
jni::Local<jni::Object<Layer>> FillExtrusionJavaLayerPeerFactory::createJavaLayerPeer(
jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
return createJavaPeer(env,
new FillExtrusionLayer(std::unique_ptr<mbgl::style::FillExtrusionLayer>(
static_cast<mbgl::style::FillExtrusionLayer*>(layer.release()))));
}
jni::Local<jni::Object<Layer>> FillExtrusionJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
return createJavaPeer(env, new FillExtrusionLayer(std::unique_ptr<mbgl::style::FillExtrusionLayer>(static_cast<mbgl::style::FillExtrusionLayer*>(layer.release()))));
}
void FillExtrusionJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
// Lookup the class
static auto& javaClass = jni::Class<FillExtrusionLayer>::Singleton(env);
void FillExtrusionJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
// Lookup the class
static auto& javaClass = jni::Class<FillExtrusionLayer>::Singleton(env);
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
// Register the peer
jni::RegisterNativePeer<FillExtrusionLayer>(
env,
javaClass,
"nativePtr",
jni::MakePeer<FillExtrusionLayer, jni::String&, jni::String&>,
"initialize",
"finalize",
METHOD(&FillExtrusionLayer::getFillExtrusionOpacityTransition, "nativeGetFillExtrusionOpacityTransition"),
METHOD(&FillExtrusionLayer::setFillExtrusionOpacityTransition, "nativeSetFillExtrusionOpacityTransition"),
METHOD(&FillExtrusionLayer::getFillExtrusionOpacity, "nativeGetFillExtrusionOpacity"),
METHOD(&FillExtrusionLayer::getFillExtrusionColorTransition, "nativeGetFillExtrusionColorTransition"),
METHOD(&FillExtrusionLayer::setFillExtrusionColorTransition, "nativeSetFillExtrusionColorTransition"),
METHOD(&FillExtrusionLayer::getFillExtrusionColor, "nativeGetFillExtrusionColor"),
METHOD(&FillExtrusionLayer::getFillExtrusionTranslateTransition, "nativeGetFillExtrusionTranslateTransition"),
METHOD(&FillExtrusionLayer::setFillExtrusionTranslateTransition, "nativeSetFillExtrusionTranslateTransition"),
METHOD(&FillExtrusionLayer::getFillExtrusionTranslate, "nativeGetFillExtrusionTranslate"),
METHOD(&FillExtrusionLayer::getFillExtrusionTranslateAnchor, "nativeGetFillExtrusionTranslateAnchor"),
METHOD(&FillExtrusionLayer::getFillExtrusionPatternTransition, "nativeGetFillExtrusionPatternTransition"),
METHOD(&FillExtrusionLayer::setFillExtrusionPatternTransition, "nativeSetFillExtrusionPatternTransition"),
METHOD(&FillExtrusionLayer::getFillExtrusionPattern, "nativeGetFillExtrusionPattern"),
METHOD(&FillExtrusionLayer::getFillExtrusionHeightTransition, "nativeGetFillExtrusionHeightTransition"),
METHOD(&FillExtrusionLayer::setFillExtrusionHeightTransition, "nativeSetFillExtrusionHeightTransition"),
METHOD(&FillExtrusionLayer::getFillExtrusionHeight, "nativeGetFillExtrusionHeight"),
METHOD(&FillExtrusionLayer::getFillExtrusionBaseTransition, "nativeGetFillExtrusionBaseTransition"),
METHOD(&FillExtrusionLayer::setFillExtrusionBaseTransition, "nativeSetFillExtrusionBaseTransition"),
METHOD(&FillExtrusionLayer::getFillExtrusionBase, "nativeGetFillExtrusionBase"),
METHOD(&FillExtrusionLayer::getFillExtrusionVerticalGradient, "nativeGetFillExtrusionVerticalGradient"));
}
// Register the peer
jni::RegisterNativePeer<FillExtrusionLayer>(
env,
javaClass,
"nativePtr",
jni::MakePeer<FillExtrusionLayer, jni::String&, jni::String&>,
"initialize",
"finalize",
METHOD(&FillExtrusionLayer::getFillExtrusionOpacityTransition, "nativeGetFillExtrusionOpacityTransition"),
METHOD(&FillExtrusionLayer::setFillExtrusionOpacityTransition, "nativeSetFillExtrusionOpacityTransition"),
METHOD(&FillExtrusionLayer::getFillExtrusionOpacity, "nativeGetFillExtrusionOpacity"),
METHOD(&FillExtrusionLayer::getFillExtrusionColorTransition, "nativeGetFillExtrusionColorTransition"),
METHOD(&FillExtrusionLayer::setFillExtrusionColorTransition, "nativeSetFillExtrusionColorTransition"),
METHOD(&FillExtrusionLayer::getFillExtrusionColor, "nativeGetFillExtrusionColor"),
METHOD(&FillExtrusionLayer::getFillExtrusionTranslateTransition, "nativeGetFillExtrusionTranslateTransition"),
METHOD(&FillExtrusionLayer::setFillExtrusionTranslateTransition, "nativeSetFillExtrusionTranslateTransition"),
METHOD(&FillExtrusionLayer::getFillExtrusionTranslate, "nativeGetFillExtrusionTranslate"),
METHOD(&FillExtrusionLayer::getFillExtrusionTranslateAnchor, "nativeGetFillExtrusionTranslateAnchor"),
METHOD(&FillExtrusionLayer::getFillExtrusionPatternTransition, "nativeGetFillExtrusionPatternTransition"),
METHOD(&FillExtrusionLayer::setFillExtrusionPatternTransition, "nativeSetFillExtrusionPatternTransition"),
METHOD(&FillExtrusionLayer::getFillExtrusionPattern, "nativeGetFillExtrusionPattern"),
METHOD(&FillExtrusionLayer::getFillExtrusionHeightTransition, "nativeGetFillExtrusionHeightTransition"),
METHOD(&FillExtrusionLayer::setFillExtrusionHeightTransition, "nativeSetFillExtrusionHeightTransition"),
METHOD(&FillExtrusionLayer::getFillExtrusionHeight, "nativeGetFillExtrusionHeight"),
METHOD(&FillExtrusionLayer::getFillExtrusionBaseTransition, "nativeGetFillExtrusionBaseTransition"),
METHOD(&FillExtrusionLayer::setFillExtrusionBaseTransition, "nativeSetFillExtrusionBaseTransition"),
METHOD(&FillExtrusionLayer::getFillExtrusionBase, "nativeGetFillExtrusionBase"),
METHOD(&FillExtrusionLayer::getFillExtrusionVerticalGradient, "nativeGetFillExtrusionVerticalGradient"));
}
} // namespace android
} // namespace mbgl

4
platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/fill_extrusion_layer.hpp
View File

@@ -56,7 +56,7 @@ public:
}; // class FillExtrusionLayer
class FillExtrusionJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::FillExtrusionLayerFactory {
class FillExtrusionJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::FillExtrusionLayerFactory {
public:
~FillExtrusionJavaLayerPeerFactory() override;
@@ -68,7 +68,7 @@ public:
LayerFactory* getLayerFactory() final { return this; }
}; // class FillExtrusionJavaLayerPeerFactory
}; // class FillExtrusionJavaLayerPeerFactory
} // namespace android
} // namespace mbgl

Some files were not shown because too many files have changed in this diff Show More