[core] Interface and implementation for offline

1 files changed, 97 insertions, 1 deletions

diff --git a/platform/default/default_file_source.cpp b/platform/default/default_file_source.cpp
index efe893d49b..5bb171f7c2 100644
--- a/platform/default/default_file_source.cpp
+++ b/platform/default/default_file_source.cpp
@@ -2,6 +2,7 @@
 #include <mbgl/storage/asset_file_source.hpp>
 #include <mbgl/storage/online_file_source.hpp>
 #include <mbgl/storage/offline_database.hpp>
+#include <mbgl/storage/offline_download.hpp>
 
 #include <mbgl/platform/platform.hpp>
 #include <mbgl/util/url.hpp>
@@ -61,6 +62,58 @@ public:
         return onlineFileSource.getAccessToken();
     }
 
+    void listRegions(std::function<void (std::exception_ptr, optional<std::vector<OfflineRegion>>)> callback) {
+        try {
+            callback({}, offlineDatabase.listRegions());
+        } catch (...) {
+            callback(std::current_exception(), {});
+        }
+    }
+
+    void createRegion(const OfflineRegionDefinition& definition,
+                      const OfflineRegionMetadata& metadata,
+                      std::function<void (std::exception_ptr, optional<OfflineRegion>)> callback) {
+        try {
+            callback({}, offlineDatabase.createRegion(definition, metadata));
+        } catch (...) {
+            callback(std::current_exception(), {});
+        }
+    }
+
+    void getRegionStatus(int64_t regionID, std::function<void (std::exception_ptr, optional<OfflineRegionStatus>)> callback) {
+        try {
+            callback({}, getDownload(regionID).getStatus());
+        } catch (...) {
+            callback(std::current_exception(), {});
+        }
+    }
+
+    void deleteRegion(OfflineRegion&& region, std::function<void (std::exception_ptr)> callback) {
+        try {
+            offlineDatabase.deleteRegion(std::move(region));
+            callback({});
+        } catch (...) {
+            callback(std::current_exception());
+        }
+    }
+
+    void removeUnusedOfflineResources(std::function<void (std::exception_ptr)> callback) {
+        try {
+            offlineDatabase.removeUnusedResources();
+            callback({});
+        } catch (...) {
+            callback(std::current_exception());
+        }
+    }
+
+    void setRegionObserver(int64_t regionID, std::unique_ptr<OfflineRegionObserver> observer) {
+        getDownload(regionID).setObserver(std::move(observer));
+    }
+
+    void setRegionDownloadState(int64_t regionID, OfflineRegionDownloadState state) {
+        getDownload(regionID).setState(state);
+    }
+
     void add(FileRequest* req, Resource resource, Callback callback) {
         tasks[req] = std::make_unique<Task>(resource, callback, this);
     }
@@ -77,15 +130,26 @@ public:
         offline = true;
     }
 
+private:
+    OfflineDownload& getDownload(int64_t regionID) {
+        auto it = downloads.find(regionID);
+        if (it != downloads.end()) {
+            return *it->second;
+        }
+        return *downloads.emplace(regionID,
+            std::make_unique<OfflineDownload>(regionID, offlineDatabase.getRegionDefinition(regionID), offlineDatabase, onlineFileSource)).first->second;
+    }
+
     OfflineDatabase offlineDatabase;
     OnlineFileSource onlineFileSource;
     std::unordered_map<FileRequest*, std::unique_ptr<Task>> tasks;
+    std::unordered_map<int64_t, std::unique_ptr<OfflineDownload>> downloads;
     bool offline = false;
 };
 
 class DefaultFileRequest : public FileRequest {
 public:
-    DefaultFileRequest(Resource     resource, FileSource::Callback callback, util::Thread<DefaultFileSource::Impl>& thread_)
+    DefaultFileRequest(Resource resource, FileSource::Callback callback, util::Thread<DefaultFileSource::Impl>& thread_)
         : thread(thread_),
           workRequest(thread.invokeWithCallback(&DefaultFileSource::Impl::add, callback, this, resource)) {
     }
@@ -129,6 +193,38 @@ std::unique_ptr<FileRequest> DefaultFileSource::request(const Resource& resource
     }
 }
 
+void DefaultFileSource::listOfflineRegions(std::function<void (std::exception_ptr, optional<std::vector<OfflineRegion>>)> callback) {
+    thread->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);
+}
+
+void DefaultFileSource::deleteOfflineRegion(OfflineRegion&& region, std::function<void (std::exception_ptr)> callback) {
+    thread->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));
+}
+
+void DefaultFileSource::setOfflineRegionDownloadState(OfflineRegion& region, OfflineRegionDownloadState state) {
+    thread->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);
+}
+
+void DefaultFileSource::removeUnusedOfflineResources(std::function<void (std::exception_ptr)> callback) {
+    thread->invoke(&Impl::removeUnusedOfflineResources, callback);
+}
+
+// For testing only:
+
 void DefaultFileSource::put(const Resource& resource, const Response& response) {
     thread->invokeSync(&Impl::put, resource, response);
 }