1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
#include <mbgl/style/tile_source_impl.hpp>
#include <mbgl/style/source_observer.hpp>
#include <mbgl/style/rapidjson_conversion.hpp>
#include <mbgl/style/conversion/tileset.hpp>
#include <mbgl/util/tileset.hpp>
#include <mbgl/util/mapbox.hpp>
#include <mbgl/storage/file_source.hpp>
#include <rapidjson/document.h>
#include <rapidjson/error/en.h>
#include <sstream>
namespace mbgl {
namespace style {
Tileset TileSourceImpl::parseTileJSON(const std::string& json, const std::string& sourceURL, SourceType type, uint16_t tileSize) {
rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> document;
document.Parse<0>(json.c_str());
if (document.HasParseError()) {
std::stringstream message;
message << document.GetErrorOffset() << " - " << rapidjson::GetParseError_En(document.GetParseError());
throw std::runtime_error(message.str());
}
conversion::Result<Tileset> result = conversion::convert<Tileset>(document);
if (!result) {
throw std::runtime_error(result.error().message);
}
// TODO: Remove this hack by delivering proper URLs in the TileJSON to begin with.
if (util::mapbox::isMapboxURL(sourceURL)) {
for (auto& url : (*result).tiles) {
url = util::mapbox::canonicalizeTileURL(url, type, tileSize);
}
}
return *result;
}
TileSourceImpl::TileSourceImpl(SourceType type_, std::string id_, Source& base_,
variant<std::string, Tileset> urlOrTileset_,
uint16_t tileSize_)
: Impl(type_, std::move(id_), base_),
urlOrTileset(std::move(urlOrTileset_)),
tileSize(tileSize_) {
}
TileSourceImpl::~TileSourceImpl() = default;
void TileSourceImpl::loadDescription(FileSource& fileSource) {
if (urlOrTileset.is<Tileset>()) {
tileset = urlOrTileset.get<Tileset>();
loaded = true;
return;
}
if (req) {
return;
}
const std::string& url = urlOrTileset.get<std::string>();
req = fileSource.request(Resource::source(url), [this, url](Response res) {
if (res.error) {
observer->onSourceError(base, std::make_exception_ptr(std::runtime_error(res.error->message)));
} else if (res.notModified) {
return;
} else if (res.noContent) {
observer->onSourceError(base, std::make_exception_ptr(std::runtime_error("unexpectedly empty TileJSON")));
} else {
Tileset newTileset;
// Create a new copy of the Tileset object that holds the base values we've parsed
// from the stylesheet. Then merge in the values parsed from the TileJSON we retrieved
// via the URL.
try {
newTileset = parseTileJSON(*res.data, url, type, tileSize);
} catch (...) {
observer->onSourceError(base, std::current_exception());
return;
}
// Check whether previous information specifies different tile
bool attributionChanged = false;
if (tileset.tiles != newTileset.tiles) {
// Tile URLs changed: force tiles to be reloaded.
invalidateTiles();
// Tile size changed: We need to recalculate the tiles we need to load because we
// might have to load tiles for a different zoom level
// This is done automatically when we trigger the onSourceLoaded observer below.
// Min/Max zoom changed: We need to recalculate what tiles to load, if we have tiles
// loaded that are outside the new zoom range
// This is done automatically when we trigger the onSourceLoaded observer below.
// Attribution changed: We need to notify the embedding application that this
// changed.
attributionChanged = true;
// Center/bounds changed: We're not using these values currently
}
tileset = newTileset;
loaded = true;
observer->onSourceLoaded(base);
if (attributionChanged) {
observer->onSourceAttributionChanged(base, newTileset.attribution);
}
}
});
}
Range<uint8_t> TileSourceImpl::getZoomRange() {
assert(loaded);
return tileset.zoomRange;
}
optional<std::string> TileSourceImpl::getAttribution() const {
if (loaded && !tileset.attribution.empty()) {
return tileset.attribution;
} else {
return {};
}
}
} // namespace style
} // namespace mbgl
|
