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

[core] Removed dependency on uv_loop from the file source

Browse Source
This commit is contained in:
Thiago Marcos P. Santos
2015-10-21 17:08:59 -07:00
parent d422c8cac4
commit 0d8ea6c0a2
8 changed files with 37 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
include/mbgl/storage/network_status.hpp
View File

@@ -4,22 +4,24 @@
#include <mutex>
#include <set>
typedef struct uv_async_s uv_async_t;
namespace mbgl {
namespace util {
class AsyncTask;
}
class NetworkStatus {
public:
static void Reachable();
static void Subscribe(uv_async_t *async);
static void Unsubscribe(uv_async_t *async);
static void Subscribe(util::AsyncTask* async);
static void Unsubscribe(util::AsyncTask* async);
private:
static std::mutex mtx;
static std::set<uv_async_t *> observers;
static std::set<util::AsyncTask*> observers;
};
}
#endif
#endif

11
platform/default/asset_request_fs.cpp
View File

@@ -1,6 +1,7 @@
#include <mbgl/storage/asset_context_base.hpp>
#include <mbgl/storage/resource.hpp>
#include <mbgl/storage/response.hpp>
#include <mbgl/util/run_loop.hpp>
#include <mbgl/util/util.hpp>
#include <mbgl/util/url.hpp>
#include <mbgl/util/uv.hpp>
@@ -17,7 +18,7 @@ class AssetRequest : public RequestBase {
MBGL_STORE_THREAD(tid)
public:
AssetRequest(const Resource&, Callback, uv_loop_t*, const std::string& assetRoot);
AssetRequest(const Resource&, Callback, const std::string& assetRoot);
~AssetRequest();
void cancel() final;
@@ -40,9 +41,8 @@ public:
class AssetFSContext : public AssetContextBase {
RequestBase* createRequest(const Resource& resource,
RequestBase::Callback callback,
uv_loop_t* loop,
const std::string& assetRoot) final {
return new AssetRequest(resource, callback, loop, assetRoot);
return new AssetRequest(resource, callback, assetRoot);
}
};
@@ -50,7 +50,7 @@ AssetRequest::~AssetRequest() {
MBGL_VERIFY_THREAD(tid);
}
AssetRequest::AssetRequest(const Resource& resource_, Callback callback_, uv_loop_t* loop, const std::string& assetRoot_)
AssetRequest::AssetRequest(const Resource& resource_, Callback callback_, const std::string& assetRoot_)
: RequestBase(resource_, callback_),
assetRoot(assetRoot_) {
req.data = this;
@@ -65,6 +65,7 @@ AssetRequest::AssetRequest(const Resource& resource_, Callback callback_, uv_loo
path = assetRoot + "/" + mbgl::util::percentDecode(url.substr(8));
}
auto loop = static_cast<uv_loop_t*>(util::RunLoop::getLoopHandle());
uv_fs_open(loop, &req, path.c_str(), O_RDONLY, S_IRUSR, fileOpened);
}
@@ -217,7 +218,7 @@ void AssetRequest::cancel() {
uv_cancel((uv_req_t *)&req);
}
std::unique_ptr<AssetContextBase> AssetContextBase::createContext(uv_loop_t*) {
std::unique_ptr<AssetContextBase> AssetContextBase::createContext() {
return std::make_unique<AssetFSContext>();
}

11
platform/default/asset_request_zip.cpp
View File

@@ -6,6 +6,7 @@
#include <mbgl/util/chrono.hpp>
#include <mbgl/util/util.hpp>
#include <mbgl/util/uv.hpp>
#include <mbgl/util/run_loop.hpp>
#include <uv.h>
#include "uv_zip.h"
@@ -18,12 +19,11 @@ namespace mbgl {
class AssetZipContext : public AssetContextBase {
public:
explicit AssetZipContext(uv_loop_t *loop);
explicit AssetZipContext();
~AssetZipContext();
RequestBase* createRequest(const Resource& resource,
RequestBase::Callback callback,
uv_loop_t* loop,
const std::string& assetRoot) final;
uv_zip_t *getHandle(const std::string &path);
@@ -34,7 +34,7 @@ public:
uv_loop_t *loop;
};
AssetZipContext::AssetZipContext(uv_loop_t *loop_) : loop(loop_) {
AssetZipContext::AssetZipContext() : loop(static_cast<uv_loop_t*>(util::RunLoop::getLoopHandle())) {
}
uv_zip_t *AssetZipContext::getHandle(const std::string &path) {
@@ -96,7 +96,6 @@ private:
RequestBase* AssetZipContext::createRequest(const Resource& resource,
RequestBase::Callback callback,
uv_loop_t*,
const std::string& assetRoot) {
return new AssetRequest(*this, resource, callback, assetRoot);
}
@@ -260,8 +259,8 @@ void AssetRequest::cancel() {
cancelled = true;
}
std::unique_ptr<AssetContextBase> AssetContextBase::createContext(uv_loop_t* loop) {
return std::make_unique<AssetZipContext>(loop);
std::unique_ptr<AssetContextBase> AssetContextBase::createContext() {
return std::make_unique<AssetZipContext>();
}
}

5
src/mbgl/storage/asset_context_base.hpp
View File

@@ -3,18 +3,15 @@
#include <mbgl/storage/request_base.hpp>
typedef struct uv_loop_s uv_loop_t;
namespace mbgl {
class AssetContextBase {
public:
static std::unique_ptr<AssetContextBase> createContext(uv_loop_t*);
static std::unique_ptr<AssetContextBase> createContext();
virtual ~AssetContextBase() = default;
virtual RequestBase* createRequest(const Resource&,
RequestBase::Callback,
uv_loop_t*,
const std::string& assetRoot) = 0;
};

19
src/mbgl/storage/default_file_source.cpp
View File

@@ -78,21 +78,20 @@ void DefaultFileSource::cancel(const Resource& res, FileRequest* req) {
// ----- Impl -----
DefaultFileSource::Impl::Impl(FileCache* cache_, const std::string& root)
: loop(reinterpret_cast<uv_loop_t*>(util::RunLoop::getLoopHandle())),
cache(cache_),
: cache(cache_),
assetRoot(root.empty() ? platform::assetRoot() : root),
assetContext(AssetContextBase::createContext(loop)),
httpContext(HTTPContextBase::createContext(loop)),
reachability(std::make_unique<uv::async>(loop, std::bind(&Impl::networkIsReachableAgain, this))) {
assetContext(AssetContextBase::createContext()),
httpContext(HTTPContextBase::createContext()),
reachability(std::bind(&Impl::networkIsReachableAgain, this)) {
// Subscribe to network status changes, but make sure that this async handle doesn't keep the
// loop alive; otherwise our app wouldn't terminate. After all, we only need status change
// notifications when our app is still running.
NetworkStatus::Subscribe(reachability->get());
reachability->unref();
NetworkStatus::Subscribe(&reachability);
reachability.unref();
}
DefaultFileSource::Impl::~Impl() {
NetworkStatus::Unsubscribe(reachability->get());
NetworkStatus::Unsubscribe(&reachability);
}
void DefaultFileSource::Impl::networkIsReachableAgain() {
@@ -202,10 +201,10 @@ void DefaultFileSource::Impl::startRealRequest(DefaultFileRequestImpl& request)
if (algo::starts_with(request.resource.url, "asset://")) {
request.realRequest =
assetContext->createRequest(request.resource, callback, loop, assetRoot);
assetContext->createRequest(request.resource, callback, assetRoot);
} else {
request.realRequest =
httpContext->createRequest(request.resource, callback, loop, request.getResponse());
httpContext->createRequest(request.resource, callback, request.getResponse());
}
}

4
src/mbgl/storage/default_file_source_impl.hpp
View File

@@ -4,6 +4,7 @@
#include <mbgl/storage/default_file_source.hpp>
#include <mbgl/storage/asset_context_base.hpp>
#include <mbgl/storage/http_context_base.hpp>
#include <mbgl/util/async_task.hpp>
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/util/chrono.hpp>
@@ -101,12 +102,11 @@ private:
void reschedule(DefaultFileRequestImpl&);
std::unordered_map<Resource, std::unique_ptr<DefaultFileRequestImpl>, Resource::Hash> pending;
uv_loop_t* const loop;
FileCache* const cache;
const std::string assetRoot;
const std::unique_ptr<AssetContextBase> assetContext;
const std::unique_ptr<HTTPContextBase> httpContext;
const std::unique_ptr<uv::async> reachability;
util::AsyncTask reachability;
};
}

4
src/mbgl/storage/http_context_base.hpp
View File

@@ -4,7 +4,6 @@
#include <mbgl/storage/request_base.hpp>
#include <mbgl/storage/http_request_base.hpp>
#include <mbgl/storage/network_status.hpp>
#include <mbgl/util/uv_detail.hpp>
#include <set>
@@ -12,12 +11,11 @@ namespace mbgl {
class HTTPContextBase {
public:
static std::unique_ptr<HTTPContextBase> createContext(uv_loop_t*);
static std::unique_ptr<HTTPContextBase> createContext();
virtual ~HTTPContextBase() = default;
virtual HTTPRequestBase* createRequest(const Resource&,
RequestBase::Callback,
uv_loop_t*,
std::shared_ptr<const Response>) = 0;
};

10
src/mbgl/storage/network_status.cpp
View File

@@ -1,6 +1,6 @@
#include <mbgl/storage/network_status.hpp>
#include <uv.h>
#include <mbgl/util/async_task.hpp>
// Example: Allocate a reachability object
// Reachability* reach = [Reachability reachabilityForInternetConnection];
@@ -10,14 +10,14 @@
namespace mbgl {
std::mutex NetworkStatus::mtx;
std::set<uv_async_t *> NetworkStatus::observers;
std::set<util::AsyncTask *> NetworkStatus::observers;
void NetworkStatus::Subscribe(uv_async_t *async) {
void NetworkStatus::Subscribe(util::AsyncTask *async) {
std::lock_guard<std::mutex> lock(NetworkStatus::mtx);
observers.insert(async);
}
void NetworkStatus::Unsubscribe(uv_async_t *async) {
void NetworkStatus::Unsubscribe(util::AsyncTask *async) {
std::lock_guard<std::mutex> lock(NetworkStatus::mtx);
observers.erase(async);
}
@@ -25,7 +25,7 @@ void NetworkStatus::Unsubscribe(uv_async_t *async) {
void NetworkStatus::Reachable() {
std::lock_guard<std::mutex> lock(NetworkStatus::mtx);
for (auto async : observers) {
uv_async_send(async);
async->send();
}
}