[core] Introduce Tile::setMinimumUpdateInterval()

src/mbgl/tile/raster_dem_tile.cpp

@@ -122,4 +122,8 @@ void RasterDEMTile::setNecessity(TileNecessity necessity) {
     loader.setNecessity(necessity);
 }
 
+void RasterDEMTile::setMinimumUpdateInterval(Duration interval) {
+    loader.setMinimumUpdateInterval(interval);
+}
+
 } // namespace mbgl

src/mbgl/tile/raster_dem_tile.hpp

@@ -67,7 +67,8 @@ public:
     ~RasterDEMTile() override;
 
     std::unique_ptr<TileRenderData> createRenderData() override;
-    void setNecessity(TileNecessity) final;
+    void setNecessity(TileNecessity) override;
+    void setMinimumUpdateInterval(Duration) override;
 
     void setError(std::exception_ptr);
     void setMetadata(optional<Timestamp> modified, optional<Timestamp> expires);

src/mbgl/tile/raster_tile.cpp

@@ -78,4 +78,8 @@ void RasterTile::setNecessity(TileNecessity necessity) {
     loader.setNecessity(necessity);
 }
 
+void RasterTile::setMinimumUpdateInterval(Duration interval) {
+    loader.setMinimumUpdateInterval(interval);
+}
+
 } // namespace mbgl

src/mbgl/tile/raster_tile.hpp

@@ -23,7 +23,8 @@ public:
     ~RasterTile() override;
 
     std::unique_ptr<TileRenderData> createRenderData() override;
-    void setNecessity(TileNecessity) final;
+    void setNecessity(TileNecessity) override;
+    void setMinimumUpdateInterval(Duration) override;
 
     void setError(std::exception_ptr);
     void setMetadata(optional<Timestamp> modified, optional<Timestamp> expires);

src/mbgl/tile/tile.hpp

@@ -52,6 +52,7 @@ public:
     void setObserver(TileObserver* observer);
 
     virtual void setNecessity(TileNecessity) {}
+    virtual void setMinimumUpdateInterval(Duration) {}
 
     // Mark this tile as no longer needed and cancel any pending work.
     virtual void cancel();

src/mbgl/tile/tile_loader.hpp

@@ -22,16 +22,8 @@ public:
                const Tileset&);
     ~TileLoader();
 
-    void setNecessity(TileNecessity newNecessity) {
-        if (newNecessity != necessity) {
-            necessity = newNecessity;
-            if (necessity == TileNecessity::Required) {
-                makeRequired();
-            } else {
-                makeOptional();
-            }
-        }
-    }
+    void setNecessity(TileNecessity newNecessity);
+    void setMinimumUpdateInterval(Duration);
 
 private:
     // called when the tile is one of the ideal tiles that we want to show definitely. the tile source
@@ -48,11 +40,16 @@ private:
     void loadedData(const Response&);
     void loadFromNetwork();
 
+    bool hasPendingNetworkRequest() const {
+        return resource.loadingMethod == Resource::LoadingMethod::NetworkOnly && request;
+    }
+
     T& tile;
     TileNecessity necessity;
     Resource resource;
     std::shared_ptr<FileSource> fileSource;
     std::unique_ptr<AsyncRequest> request;
+    Duration minimumUpdateInterval{Duration::zero()};
 };
 
 } // namespace mbgl

src/mbgl/tile/tile_loader_impl.hpp

@@ -56,6 +56,30 @@ TileLoader<T>::TileLoader(T& tile_,
 template <typename T>
 TileLoader<T>::~TileLoader() = default;
 
+template <typename T>
+void TileLoader<T>::setNecessity(TileNecessity newNecessity) {
+    if (newNecessity != necessity) {
+        necessity = newNecessity;
+        if (necessity == TileNecessity::Required) {
+            makeRequired();
+        } else {
+            makeOptional();
+        }
+    }
+}
+
+template <typename T>
+void TileLoader<T>::setMinimumUpdateInterval(Duration interval) {
+    if (minimumUpdateInterval != interval) {
+        minimumUpdateInterval = interval;
+        if (hasPendingNetworkRequest()) {
+            // Update the pending request.
+            request.reset();
+            loadFromNetwork();
+        }
+    }
+}
+
 template <typename T>
 void TileLoader<T>::loadFromCache() {
     assert(!request);
@@ -99,7 +123,7 @@ void TileLoader<T>::makeRequired() {
 
 template <typename T>
 void TileLoader<T>::makeOptional() {
-    if (resource.loadingMethod == Resource::LoadingMethod::NetworkOnly && request) {
+    if (hasPendingNetworkRequest()) {
         // Abort the current request, but only when we know that we're specifically querying for a
         // network resource only.
         request.reset();
@@ -135,6 +159,7 @@ void TileLoader<T>::loadFromNetwork() {
     // Instead of using Resource::LoadingMethod::All, we're first doing a CacheOnly, and then a
     // NetworkOnly request.
     resource.loadingMethod = Resource::LoadingMethod::NetworkOnly;
+    resource.minimumUpdateInterval = minimumUpdateInterval;
     request = fileSource->request(resource, [this](const Response& res) { loadedData(res); });
 }
 

src/mbgl/tile/vector_tile.cpp

@@ -16,6 +16,10 @@ void VectorTile::setNecessity(TileNecessity necessity) {
     loader.setNecessity(necessity);
 }
 
+void VectorTile::setMinimumUpdateInterval(Duration interval) {
+    loader.setMinimumUpdateInterval(interval);
+}
+
 void VectorTile::setMetadata(optional<Timestamp> modified_, optional<Timestamp> expires_) {
     modified = std::move(modified_);
     expires = std::move(expires_);

src/mbgl/tile/vector_tile.hpp

@@ -16,6 +16,7 @@ public:
                const Tileset&);
 
     void setNecessity(TileNecessity) final;
+    void setMinimumUpdateInterval(Duration interval) final;
     void setMetadata(optional<Timestamp> modified, optional<Timestamp> expires);
     void setData(const std::shared_ptr<const std::string>& data);