Replacing hardcoded configuration with configurable API and removing Mapbox assets (#90)

* Refactoring online file source so that tile server configuration is not hardcoded - part 1

* Added default templates

* Update from master

* Renaming MGLAccountManager to MGLSettings. Passing ResourceOptions and TileServerOptions to relevant classes and method in order to remove mapbox hardocded configuration

* Fixing build

* Addedm missing theme

* Unit tests fixes

* Fixing unit tests, adding factory methods for creating predefined configuration.

* Fixing mapbox unit tests

* Additional unit test fixes

* Making MapboxConfiguration default

* Making get/set resource options available in all classes that inherits from FileSource

* Making get/set resource options available in all classes that inherits from FileSource - part 2

* Fixes for Android

* Disable test coverage reports

* Disable test coverage reports

* Disable test coverage reports

* Disable test coverage reports

* Removing hardcoded configuration in iOS project - part 1

* Fixing wrong file extension, making use of tile server options.

* Use apiKey and MGL_API_KEY everywhere

* Just a rename

* Re-enabling tests and improving MGLSettings init

* Removing mapbox hardcoded configuration, using api key everywhere, implementing JNI conversion for TileServerOptions

* Lint issues.

* Integrating configurable tile server properties into Android SDK - part 2

* Removing mabox accounts

* Exposing multiple configurations to Android SDK - bug fixes

* Removing TileServerOptions from public interface - native methods dont work before mapbox-gl library is loaded

* Adding support for configurable predefined styles

* Migrating predefined styles in test app + cleanup

* Parameter fix

* Bug fixes

* Fixing render test build

* Fixing offline tester

* Fixing benchmark tool

* Fix: typo in method name

* Adding code for public access to TileServerOptions

* Bug fixes and debug code removal

* Fixes for macOS, adding unit tests from MapLibre, removing redundant members from OnlineFileSource

* Unit test fixes

* MacOS test app - migrating to configurable tile server options, part 1

* Fixing offline maps

* Migrating macOS test app to MapTiler

* Minor improvements

* Putting back apiKey test

* Added unit tests for MapTiler configuration

* Migrating test resources to MapTiler

* minor fix

* A few fixes

* Fixing macOS tests, removing feedback functionality

* Migrating ios test app to MapTiler

* Migrating ui tests

* UI tests fix

* Benchmarking app fix

* Cleanup and strings updates

* Migrating benchmark app to maptiler

* API key injection in benchmark app

* Putting back release configuration

* Additional tests and fixing issues identified by thread sanitizer.

* Removing test filters

* Fixes and addressing lint issues

* More Maptiler tests + minro fix

* Android instrumentation test migration to MapTiler. Exposing missing TileServerOptions in Android SDK. Minor fixes.

* No requirements on API key format.

* Fixing offline cache test tool

* Adding configurable domain name for sources, adding source domain int MapTiler configuration, cleanup

* Migrating tests to MapTiler, adding code for canonicalizing URLs, removing mapbox stuff from comments, cleanup

* More tests

* Updated database size

* Lint issues

* Fixed test

* Updating developer config API key

* Fixes for Android, propagaing updated tileServerOptions to native file sources, more tests

* Just a few more fixes

* Propagating updated settings to file sources + additional unit test

* Lint issues

* Removing test filter and fixing incorrect uri

* Release preparation

* macos release notes
This commit is contained in:
Petr Pokorny
2021-06-29 12:44:51 +02:00
committed by GitHub
parent 9a49fa16c9
commit d62ff400c6
398 changed files with 107907 additions and 184517 deletions

View File

@@ -0,0 +1,31 @@
#include "default_style.hpp"
namespace mbgl {
namespace android {
jni::Local<jni::Object<DefaultStyle>> DefaultStyle::New(jni::JNIEnv& env, const mbgl::util::DefaultStyle& jDefaultStyle) {
static auto& javaClass = jni::Class<DefaultStyle>::Singleton(env);
static auto constructor = javaClass.GetConstructor<jni::String, jni::String, int>(env);
return javaClass.New(
env,
constructor,
jni::Make<jni::String>(env, jDefaultStyle.getUrl()),
jni::Make<jni::String>(env, jDefaultStyle.getName()),
jDefaultStyle.getCurrentVersion());
}
mbgl::util::DefaultStyle DefaultStyle::getDefaultStyle(jni::JNIEnv& env, const jni::Object<DefaultStyle>& options) {
static auto& javaClass = jni::Class<DefaultStyle>::Singleton(env);
return mbgl::util::DefaultStyle (
jni::Make<std::string>(env, options.Get(env, javaClass.GetField<jni::String>(env, "url"))),
jni::Make<std::string>(env, options.Get(env, javaClass.GetField<jni::String>(env, "name"))),
options.Get(env, javaClass.GetField<int>(env, "version"))
);
}
void DefaultStyle::registerNative(jni::JNIEnv& env) {
jni::Class<DefaultStyle>::Singleton(env);
}
} // namespace android
} // namespace mbgl

View File

@@ -0,0 +1,25 @@
#pragma once
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/util/default_style.hpp>
#include <jni/jni.hpp>
namespace mbgl {
namespace android {
class DefaultStyle : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/util/DefaultStyle"; };
static jni::Local<jni::Object<DefaultStyle>> New(jni::JNIEnv&, const mbgl::util::DefaultStyle&);
static mbgl::util::DefaultStyle getDefaultStyle(jni::JNIEnv&, const jni::Object<DefaultStyle>&);
static void registerNative(jni::JNIEnv&);
};
} // namespace android
} // namespace mbgl

View File

@@ -0,0 +1,178 @@
#include "tile_server_options.hpp"
namespace mbgl {
namespace android {
jni::Local<jni::Object<TileServerOptions>> TileServerOptions::New(jni::JNIEnv& env, const mbgl::TileServerOptions& tileServerOptions) {
static auto& javaClass = jni::Class<TileServerOptions>::Singleton(env);
static auto constructor = javaClass.GetConstructor<
jni::String, jni::String, jni::String, jni::String, jni::String, jni::String,
jni::String, jni::String, jni::String, jni::String, jni::String,
jni::String, jni::String, jni::String, jni::String, jni::String,
jni::String, jni::String, jni::jboolean, jni::String, jni::Array<jni::Object<DefaultStyle>>>(env);
optional<std::string> sourceVersionPrefixValue = tileServerOptions.sourceVersionPrefix();
optional<std::string> styleVersionPrefixValue = tileServerOptions.styleVersionPrefix();
optional<std::string> spritesVersionPrefixValue = tileServerOptions.spritesVersionPrefix();
optional<std::string> glyphsVersionPrefixValue = tileServerOptions.glyphsVersionPrefix();
optional<std::string> tileVersionPrefixValue = tileServerOptions.tileVersionPrefix();
return javaClass.New(env, constructor,
jni::Make<jni::String>(env, tileServerOptions.baseURL()),
jni::Make<jni::String>(env, tileServerOptions.uriSchemeAlias()),
jni::Make<jni::String>(env, tileServerOptions.sourceTemplate()),
jni::Make<jni::String>(env, tileServerOptions.sourceDomainName()),
sourceVersionPrefixValue ? jni::Make<jni::String>(env, *sourceVersionPrefixValue) : jni::Local<jni::String>(),
jni::Make<jni::String>(env, tileServerOptions.styleTemplate()),
jni::Make<jni::String>(env, tileServerOptions.styleDomainName()),
styleVersionPrefixValue ? jni::Make<jni::String>(env, *styleVersionPrefixValue) : jni::Local<jni::String>(),
jni::Make<jni::String>(env, tileServerOptions.spritesTemplate()),
jni::Make<jni::String>(env, tileServerOptions.spritesDomainName()),
spritesVersionPrefixValue ? jni::Make<jni::String>(env, *spritesVersionPrefixValue) : jni::Local<jni::String>(),
jni::Make<jni::String>(env, tileServerOptions.glyphsTemplate()),
jni::Make<jni::String>(env, tileServerOptions.glyphsDomainName()),
glyphsVersionPrefixValue ? jni::Make<jni::String>(env, *glyphsVersionPrefixValue) : jni::Local<jni::String>(),
jni::Make<jni::String>(env, tileServerOptions.tileTemplate()),
jni::Make<jni::String>(env, tileServerOptions.tileDomainName()),
tileVersionPrefixValue ? jni::Make<jni::String>(env, *tileVersionPrefixValue) : jni::Local<jni::String>(),
jni::Make<jni::String>(env, tileServerOptions.apiKeyParameterName()),
jni::jboolean(tileServerOptions.requiresApiKey()),
jni::Make<jni::String>(env, tileServerOptions.defaultStyle()),
TileServerOptions::NewStyles(env, tileServerOptions.defaultStyles())
);
}
jni::Local<jni::Array<jni::Object<DefaultStyle>>> TileServerOptions::NewStyles(jni::JNIEnv& env, const std::vector<const mbgl::util::DefaultStyle> nativeStyles) {
auto retVal = jni::Array<jni::Object<DefaultStyle>>::New(env, nativeStyles.size());
for (auto it = begin(nativeStyles); it != end(nativeStyles); ++it) {
auto converted = DefaultStyle::New(env, *it);
retVal.Set(env, it - nativeStyles.begin(), converted);
}
return retVal;
}
jni::Local<jni::Object<TileServerOptions>> TileServerOptions::DefaultConfiguration(jni::JNIEnv& env, const jni::Class<TileServerOptions>& jOptions) {
auto options = mbgl::TileServerOptions::DefaultConfiguration();
return TileServerOptions::New(env, options);
}
jni::Local<jni::Object<TileServerOptions>> TileServerOptions::MapboxConfiguration(jni::JNIEnv& env, const jni::Class<TileServerOptions>& jOptions) {
auto options = mbgl::TileServerOptions::MapboxConfiguration();
return TileServerOptions::New(env, options);
}
jni::Local<jni::Object<TileServerOptions>> TileServerOptions::MapTilerConfiguration(jni::JNIEnv& env, const jni::Class<TileServerOptions>& jOptions) {
auto options = mbgl::TileServerOptions::MapTilerConfiguration();
return TileServerOptions::New(env, options);
}
jni::Local<jni::Object<TileServerOptions>> TileServerOptions::MapLibreConfiguration(jni::JNIEnv& env, const jni::Class<TileServerOptions>& jOptions) {
auto options = mbgl::TileServerOptions::MapLibreConfiguration();
return TileServerOptions::New(env, options);
}
mbgl::TileServerOptions TileServerOptions::getTileServerOptions(jni::JNIEnv& env, const jni::Object<TileServerOptions>& options) {
auto opts = mbgl::TileServerOptions();
static auto& javaClass = jni::Class<TileServerOptions>::Singleton(env);
static auto baseURLField = javaClass.GetField<jni::String>(env, "baseURL");
static auto uriSchemeAliasField = javaClass.GetField<jni::String>(env, "uriSchemeAlias");
static auto sourceTemplateField = javaClass.GetField<jni::String>(env, "sourceTemplate");
static auto sourceDomainNameField = javaClass.GetField<jni::String>(env, "sourceDomainName");
static auto sourceVersionPrefixField = javaClass.GetField<jni::String>(env, "sourceVersionPrefix");
static auto styleTemplateField = javaClass.GetField<jni::String>(env, "styleTemplate");
static auto styleDomainNameField = javaClass.GetField<jni::String>(env, "styleDomainName");
static auto styleVersionPrefixField = javaClass.GetField<jni::String>(env, "styleVersionPrefix");
static auto spritesTemplateField = javaClass.GetField<jni::String>(env, "spritesTemplate");
static auto spritesDomainNameField = javaClass.GetField<jni::String>(env, "spritesDomainName");
static auto spritesVersionPrefixField = javaClass.GetField<jni::String>(env, "spritesVersionPrefix");
static auto glyphsTemplateField = javaClass.GetField<jni::String>(env, "glyphsTemplate");
static auto glyphsDomainNameField = javaClass.GetField<jni::String>(env, "glyphsDomainName");
static auto glyphsVersionPrefixField = javaClass.GetField<jni::String>(env, "glyphsVersionPrefix");
static auto tileTemplateField = javaClass.GetField<jni::String>(env, "tileTemplate");
static auto tileDomainNameField = javaClass.GetField<jni::String>(env, "tileDomainName");
static auto tileVersionPrefixField = javaClass.GetField<jni::String>(env, "tileVersionPrefix");
static auto apiKeyParameterNameField = javaClass.GetField<jni::String>(env, "apiKeyParameterName");
static auto apiKeyRequiredField = javaClass.GetField<jni::jboolean>(env, "apiKeyRequired");
static auto defaultStyleField = javaClass.GetField<jni::String>(env, "defaultStyle");
static auto defaultStylesField = javaClass.GetField<jni::Array<jni::Object<DefaultStyle>>>(env, "defaultStyles");
std::vector<const mbgl::util::DefaultStyle> defaultStyles = TileServerOptions::getDefaultStyles(env, options.Get(env, defaultStylesField));
auto retVal = mbgl::TileServerOptions()
.withBaseURL(jni::Make<std::string>(env, options.Get(env, baseURLField)))
.withUriSchemeAlias(jni::Make<std::string>(env, options.Get(env, uriSchemeAliasField)))
.withApiKeyParameterName(jni::Make<std::string>(env, options.Get(env, apiKeyParameterNameField)))
.setRequiresApiKey(options.Get(env, apiKeyRequiredField));
auto sourcePrefixValue = options.Get(env, sourceVersionPrefixField);
retVal.withSourceTemplate(
jni::Make<std::string>(env, options.Get(env, sourceTemplateField)),
jni::Make<std::string>(env, options.Get(env, sourceDomainNameField)),
sourcePrefixValue ? jni::Make<std::string>(env, sourcePrefixValue): optional<std::string>{});
auto styleVersionPrefixValue = options.Get(env, styleVersionPrefixField);
retVal.withStyleTemplate(
jni::Make<std::string>(env, options.Get(env, styleTemplateField)),
jni::Make<std::string>(env, options.Get(env, styleDomainNameField)),
styleVersionPrefixValue ? jni::Make<std::string>(env, styleVersionPrefixValue): optional<std::string>{});
auto spritesVersionPrefixValue = options.Get(env, spritesVersionPrefixField);
retVal.withSpritesTemplate(
jni::Make<std::string>(env, options.Get(env, spritesTemplateField)),
jni::Make<std::string>(env, options.Get(env, spritesDomainNameField)),
spritesVersionPrefixValue ? jni::Make<std::string>(env, spritesVersionPrefixValue): optional<std::string>{});
auto glyphsVersionPrefixValue = options.Get(env, glyphsVersionPrefixField);
retVal.withGlyphsTemplate(
jni::Make<std::string>(env, options.Get(env, glyphsTemplateField)),
jni::Make<std::string>(env, options.Get(env, glyphsDomainNameField)),
glyphsVersionPrefixValue ? jni::Make<std::string>(env, glyphsVersionPrefixValue) : optional<std::string>{});
auto tileVersionPrefixValue = options.Get(env, tileVersionPrefixField);
retVal.withTileTemplate(
jni::Make<std::string>(env, options.Get(env, tileTemplateField)),
jni::Make<std::string>(env, options.Get(env, tileDomainNameField)),
tileVersionPrefixValue ? jni::Make<std::string>(env, tileVersionPrefixValue): optional<std::string>{});
retVal.withDefaultStyle(jni::Make<std::string>(env, options.Get(env, defaultStyleField)));
retVal.withDefaultStyles(defaultStyles);
return retVal;
}
std::vector<const mbgl::util::DefaultStyle> TileServerOptions::getDefaultStyles(jni::JNIEnv& env, const jni::Array<jni::Object<DefaultStyle>>& styles_) {
std::size_t length = styles_.Length(env);
std::vector<const mbgl::util::DefaultStyle> convertedStyles;
//convertedStyles.reserve(length);
for (std::size_t i = 0; i < length; i++) {
const mbgl::util::DefaultStyle converted = DefaultStyle::getDefaultStyle(env, styles_.Get(env, i));
convertedStyles.push_back(converted);
}
return convertedStyles;
}
void TileServerOptions::registerNative(jni::JNIEnv& env) {
static auto& javaClass = jni::Class<TileServerOptions>::Singleton(env);
jni::RegisterNatives(env,
*javaClass,
jni::MakeNativeMethod<decltype(&TileServerOptions::DefaultConfiguration), &TileServerOptions::DefaultConfiguration>("defaultConfiguration"),
jni::MakeNativeMethod<decltype(&TileServerOptions::MapboxConfiguration), &TileServerOptions::MapboxConfiguration>("mapboxConfiguration"),
jni::MakeNativeMethod<decltype(&TileServerOptions::MapTilerConfiguration), &TileServerOptions::MapTilerConfiguration>("mapTilerConfiguration"),
jni::MakeNativeMethod<decltype(&TileServerOptions::MapLibreConfiguration), &TileServerOptions::MapLibreConfiguration>("mapLibreConfiguration"));
}
} // namespace android
} // namespace mbgl

View File

@@ -0,0 +1,38 @@
#pragma once
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/util/tile_server_options.hpp>
#include <mbgl/util/default_style.hpp>
#include <jni/jni.hpp>
#include "default_style.hpp"
namespace mbgl {
namespace android {
class TileServerOptions : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "com/mapbox/mapboxsdk/util/TileServerOptions"; };
static jni::Local<jni::Object<TileServerOptions>> New(jni::JNIEnv&, const mbgl::TileServerOptions&);
static jni::Local<jni::Object<TileServerOptions>> DefaultConfiguration(jni::JNIEnv&, const jni::Class<TileServerOptions>&);
static jni::Local<jni::Object<TileServerOptions>> MapboxConfiguration(jni::JNIEnv&, const jni::Class<TileServerOptions>&);
static jni::Local<jni::Object<TileServerOptions>> MapTilerConfiguration(jni::JNIEnv&, const jni::Class<TileServerOptions>&);
static jni::Local<jni::Object<TileServerOptions>> MapLibreConfiguration(jni::JNIEnv&, const jni::Class<TileServerOptions>&);
static mbgl::TileServerOptions getTileServerOptions(jni::JNIEnv&, const jni::Object<TileServerOptions>&);
static void registerNative(jni::JNIEnv&);
static jni::Local<jni::Array<jni::Object<DefaultStyle>>> NewStyles(jni::JNIEnv& env, const std::vector<const mbgl::util::DefaultStyle>);
static std::vector<const mbgl::util::DefaultStyle> getDefaultStyles(jni::JNIEnv& env, const jni::Array<jni::Object<DefaultStyle>>& styles_);
};
} // namespace android
} // namespace mbgl