network_content.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef NETWORK_CONTENT_H
#define NETWORK_CONTENT_H
 
#include <ranges>
#include "core/tcp_content.h"
#include "core/http.h"
#include <unordered_map>
#include "../core/container_func.hpp"
 
using ContentVector = std::vector<std::unique_ptr<ContentInfo>>;
using ConstContentVector = std::vector<const ContentInfo *>;
 
struct ContentCallback {
  virtual void OnConnect([[maybe_unused]] bool success) {}
 
  virtual void OnDisconnect() {}
 
  virtual void OnReceiveContentInfo([[maybe_unused]] const ContentInfo &ci) {}
 
  virtual void OnDownloadProgress([[maybe_unused]] const ContentInfo &ci, [[maybe_unused]] int bytes) {}
 
  virtual void OnDownloadComplete([[maybe_unused]] ContentID cid) {}
 
  virtual ~ContentCallback() = default;
};
struct ContentCallback {…};
 
class ClientNetworkContentSocketHandler : public NetworkContentSocketHandler, ContentCallback, HTTPCallback {
protected:
  using ContentIDList = std::vector<ContentID>; 
  std::vector<ContentCallback *> callbacks; 
  ContentIDList requested; 
  ContentIDList queued; 
  ContentVector infos; 
  std::unordered_multimap<ContentID, ContentID> reverse_dependency_map; 
  std::vector<char> http_response; 
  int http_response_index = -2; 
 
  std::optional<FileHandle> cur_file; 
  std::unique_ptr<ContentInfo> cur_info; 
  bool is_connecting = false; 
  bool is_cancelled = false; 
  std::chrono::steady_clock::time_point last_activity = std::chrono::steady_clock::now(); 
 
  friend class NetworkContentConnecter;
 
  bool Receive_SERVER_INFO(Packet &p) override;
  bool Receive_SERVER_CONTENT(Packet &p) override;
 
  ContentInfo *GetContent(ContentID cid) const;
  void DownloadContentInfo(ContentID cid);
 
  void OnConnect(bool success) override;
  void OnDisconnect() override;
  void OnReceiveContentInfo(const ContentInfo &ci) override;
  void OnDownloadProgress(const ContentInfo &ci, int bytes) override;
  void OnDownloadComplete(ContentID cid) override;
 
  void OnFailure() override;
  void OnReceiveData(std::unique_ptr<char[]> data, size_t length) override;
  bool IsCancelled() const override;
 
  bool BeforeDownload();
  void AfterDownload();
 
  void DownloadSelectedContentHTTP(const ContentIDList &content);
  void DownloadSelectedContentFallback(const ContentIDList &content);
public:
  static constexpr std::chrono::seconds IDLE_TIMEOUT = std::chrono::seconds(60);
 
  void Connect();
  void SendReceive();
  NetworkRecvStatus CloseConnection(bool error = true) override;
  void Cancel();
 
  void RequestContentList(ContentType type);
  void RequestContentList(std::span<const ContentID> content_ids);
  void RequestContentList(ContentVector *cv, bool send_md5sum = true);
 
  void DownloadSelectedContent(uint &files, uint &bytes, bool fallback = false);
  void RequestQueuedContentInfo();
 
  void Select(ContentID cid);
  void Unselect(ContentID cid);
  void SelectAll();
  void SelectUpgrade();
  void UnselectAll();
  void ToggleSelectedState(const ContentInfo &ci);
 
  void ReverseLookupDependency(ConstContentVector &parents, const ContentInfo &child) const;
  void ReverseLookupTreeDependency(ConstContentVector &tree, const ContentInfo *child) const;
  void CheckDependencyState(const ContentInfo &ci);
 
  auto Info() const { return this->infos | std::views::transform([](const auto &ci) -> const ContentInfo & { return *ci; }); }
 
  void Clear();
 
  void AddCallback(ContentCallback *cb) { include(this->callbacks, cb); }
  void RemoveCallback(ContentCallback *cb) { this->callbacks.erase(std::ranges::find(this->callbacks, cb)); }
};
class ClientNetworkContentSocketHandler : public NetworkContentSocketHandler, ContentCallback, HTTPCallback {…};
 
extern ClientNetworkContentSocketHandler _network_content_client;
 
void ShowNetworkContentListWindow(ContentVector *cv = nullptr, ContentType type1 = CONTENT_TYPE_END, ContentType type2 = CONTENT_TYPE_END);
 
void ShowMissingContentWindow(const GRFConfigList &list);
 
#endif /* NETWORK_CONTENT_H */