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

[core] Convert DefaultFileSource to ThreadedObject

Browse Source 
Fixes #6426
This commit is contained in:
Thiago Marcos P. Santos
2017-05-30 21:56:46 -03:00
parent c34d1cfaa7
commit 999de53f11
2 changed files with 31 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
platform/default/default_file_source.cpp
View File

@@ -1,5 +1,6 @@
#include <mbgl/storage/default_file_source.hpp>
#include <mbgl/storage/asset_file_source.hpp>
#include <mbgl/storage/file_source_request.hpp>
#include <mbgl/storage/local_file_source.hpp>
#include <mbgl/storage/online_file_source.hpp>
#include <mbgl/storage/offline_database.hpp>
@@ -7,7 +8,7 @@
#include <mbgl/util/platform.hpp>
#include <mbgl/util/url.hpp>
#include <mbgl/util/thread.hpp>
#include <mbgl/util/threaded_object.hpp>
#include <mbgl/util/work_request.hpp>
#include <cassert>
@@ -26,7 +27,7 @@ namespace mbgl {
class DefaultFileSource::Impl {
public:
Impl(std::shared_ptr<FileSource> assetFileSource_, const std::string& cachePath, uint64_t maximumCacheSize)
Impl(ActorRef<Impl>, std::shared_ptr<FileSource> assetFileSource_, const std::string& cachePath, uint64_t maximumCacheSize)
: assetFileSource(assetFileSource_)
, localFileSource(std::make_unique<LocalFileSource>())
, offlineDatabase(cachePath, maximumCacheSize) {
@@ -106,7 +107,11 @@ public:
getDownload(regionID).setState(state);
}
void request(AsyncRequest* req, Resource resource, Callback callback) {
void request(AsyncRequest* req, Resource resource, ActorRef<FileSourceRequest> ref) {
auto callback = [ref] (const Response& res) mutable {
ref.invoke(&FileSourceRequest::setResponse, res);
};
if (isAssetURL(resource.url)) {
//Asset request
tasks[req] = assetFileSource->request(resource, callback);
@@ -140,7 +145,7 @@ public:
// Get from the online file source
if (resource.necessity == Resource::Required) {
tasks[req] = onlineFileSource.request(revalidation, [=] (Response onlineResponse) {
tasks[req] = onlineFileSource.request(revalidation, [=] (Response onlineResponse) mutable {
this->offlineDatabase.put(revalidation, onlineResponse);
callback(onlineResponse);
});
@@ -189,14 +194,13 @@ DefaultFileSource::DefaultFileSource(const std::string& cachePath,
std::unique_ptr<FileSource>&& assetFileSource_,
uint64_t maximumCacheSize)
: assetFileSource(std::move(assetFileSource_))
, thread(std::make_unique<util::Thread<Impl>>(util::ThreadContext{"DefaultFileSource", util::ThreadPriority::Low},
assetFileSource, cachePath, maximumCacheSize)) {
, impl(std::make_unique<util::ThreadedObject<Impl>>("DefaultFileSource", assetFileSource, cachePath, maximumCacheSize)) {
}
DefaultFileSource::~DefaultFileSource() = default;
void DefaultFileSource::setAPIBaseURL(const std::string& baseURL) {
thread->invoke(&Impl::setAPIBaseURL, baseURL);
impl->actor().invoke(&Impl::setAPIBaseURL, baseURL);
{
std::lock_guard<std::mutex> lock(cachedBaseURLMutex);
@@ -210,7 +214,7 @@ std::string DefaultFileSource::getAPIBaseURL() {
}
void DefaultFileSource::setAccessToken(const std::string& accessToken) {
thread->invoke(&Impl::setAccessToken, accessToken);
impl->actor().invoke(&Impl::setAccessToken, accessToken);
{
std::lock_guard<std::mutex> lock(cachedAccessTokenMutex);
@@ -226,83 +230,74 @@ std::string DefaultFileSource::getAccessToken() {
void DefaultFileSource::setResourceTransform(std::function<std::string(Resource::Kind, std::string&&)> transform) {
if (transform) {
auto loop = util::RunLoop::Get();
thread->invoke(&Impl::setResourceTransform, [loop, transform](Resource::Kind kind_, std::string&& url_, auto callback_) {
impl->actor().invoke(&Impl::setResourceTransform, [loop, transform](Resource::Kind kind_, std::string&& url_, auto callback_) {
return loop->invokeWithCallback([transform](Resource::Kind kind, std::string&& url, auto callback) {
callback(transform(kind, std::move(url)));
}, kind_, std::move(url_), callback_);
});
} else {
thread->invoke(&Impl::setResourceTransform, nullptr);
impl->actor().invoke(&Impl::setResourceTransform, nullptr);
}
}
std::unique_ptr<AsyncRequest> DefaultFileSource::request(const Resource& resource, Callback callback) {
class DefaultFileRequest : public AsyncRequest {
public:
DefaultFileRequest(Resource resource_, FileSource::Callback callback_, util::Thread<DefaultFileSource::Impl>& thread_)
: thread(thread_),
workRequest(thread.invokeWithCallback(&DefaultFileSource::Impl::request, this, resource_, callback_)) {
}
auto req = std::make_unique<FileSourceRequest>(std::move(callback));
~DefaultFileRequest() override {
thread.invoke(&DefaultFileSource::Impl::cancel, this);
}
req->onCancel([fs = impl->actor(), req = req.get()] () mutable { fs.invoke(&Impl::cancel, req); });
util::Thread<DefaultFileSource::Impl>& thread;
std::unique_ptr<AsyncRequest> workRequest;
};
impl->actor().invoke(&Impl::request, req.get(), resource, req->actor());
return std::make_unique<DefaultFileRequest>(resource, callback, *thread);
return std::move(req);
}
void DefaultFileSource::listOfflineRegions(std::function<void (std::exception_ptr, optional<std::vector<OfflineRegion>>)> callback) {
thread->invoke(&Impl::listRegions, callback);
impl->actor().invoke(&Impl::listRegions, callback);
}
void DefaultFileSource::createOfflineRegion(const OfflineRegionDefinition& definition,
const OfflineRegionMetadata& metadata,
std::function<void (std::exception_ptr, optional<OfflineRegion>)> callback) {
thread->invoke(&Impl::createRegion, definition, metadata, callback);
impl->actor().invoke(&Impl::createRegion, definition, metadata, callback);
}
void DefaultFileSource::updateOfflineMetadata(const int64_t regionID,
const OfflineRegionMetadata& metadata,
std::function<void (std::exception_ptr, optional<OfflineRegionMetadata>)> callback) {
thread->invoke(&Impl::updateMetadata, regionID, metadata, callback);
impl->actor().invoke(&Impl::updateMetadata, regionID, metadata, callback);
}
void DefaultFileSource::deleteOfflineRegion(OfflineRegion&& region, std::function<void (std::exception_ptr)> callback) {
thread->invoke(&Impl::deleteRegion, std::move(region), callback);
impl->actor().invoke(&Impl::deleteRegion, std::move(region), callback);
}
void DefaultFileSource::setOfflineRegionObserver(OfflineRegion& region, std::unique_ptr<OfflineRegionObserver> observer) {
thread->invoke(&Impl::setRegionObserver, region.getID(), std::move(observer));
impl->actor().invoke(&Impl::setRegionObserver, region.getID(), std::move(observer));
}
void DefaultFileSource::setOfflineRegionDownloadState(OfflineRegion& region, OfflineRegionDownloadState state) {
thread->invoke(&Impl::setRegionDownloadState, region.getID(), state);
impl->actor().invoke(&Impl::setRegionDownloadState, region.getID(), state);
}
void DefaultFileSource::getOfflineRegionStatus(OfflineRegion& region, std::function<void (std::exception_ptr, optional<OfflineRegionStatus>)> callback) const {
thread->invoke(&Impl::getRegionStatus, region.getID(), callback);
impl->actor().invoke(&Impl::getRegionStatus, region.getID(), callback);
}
void DefaultFileSource::setOfflineMapboxTileCountLimit(uint64_t limit) const {
thread->invokeSync(&Impl::setOfflineMapboxTileCountLimit, limit);
impl->actor().invoke(&Impl::setOfflineMapboxTileCountLimit, limit);
}
void DefaultFileSource::pause() {
thread->pause();
impl->pause();
}
void DefaultFileSource::resume() {
thread->resume();
impl->resume();
}
// For testing only:
void DefaultFileSource::put(const Resource& resource, const Response& response) {
thread->invokeSync(&Impl::put, resource, response);
impl->actor().invoke(&Impl::put, resource, response);
}
} // namespace mbgl