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

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) {