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 "core/tcp_content.h"
#include "core/http.h"
#include <unordered_map>
#include "../core/container_func.hpp"
 
typedef std::vector<ContentInfo *> ContentVector;
typedef std::vector<const ContentInfo *> ConstContentVector;
 
typedef ContentInfo **ContentIterator;
typedef const ContentInfo * const * ConstContentIterator;
 
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;
};
 
class ClientNetworkContentSocketHandler : public NetworkContentSocketHandler, ContentCallback, HTTPCallback {
protected:
  typedef std::vector<ContentID> ContentIDList; 
  std::vector<ContentCallback *> callbacks;     
  ContentIDList requested;                      
  ContentVector infos;                          
  std::unordered_multimap<ContentID, ContentID> reverse_dependency_map; 
  std::vector<char> http_response;              
  int http_response_index;                      
 
  std::optional<FileHandle> curFile; 
  ContentInfo *curInfo; 
  bool isConnecting;    
  bool isCancelled;     
  std::chrono::steady_clock::time_point lastActivity;  
 
  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);
 
  ClientNetworkContentSocketHandler();
  ~ClientNetworkContentSocketHandler();
 
  void Connect();
  void SendReceive();
  NetworkRecvStatus CloseConnection(bool error = true) override;
  void Cancel();
 
  void RequestContentList(ContentType type);
  void RequestContentList(uint count, const ContentID *content_ids);
  void RequestContentList(ContentVector *cv, bool send_md5sum = true);
 
  void DownloadSelectedContent(uint &files, uint &bytes, bool fallback = false);
 
  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(ContentInfo *ci);
 
  uint Length() const { return (uint)this->infos.size(); }
  ConstContentIterator Begin() const { return this->infos.data(); }
  ConstContentIterator Get(uint32_t index) const { return this->infos.data() + index; }
  ConstContentIterator End() const { return this->Begin() + this->Length(); }
 
  void Clear();
 
  void AddCallback(ContentCallback *cb) { include(this->callbacks, cb); }
  void RemoveCallback(ContentCallback *cb) { this->callbacks.erase(std::find(this->callbacks.begin(), this->callbacks.end(), cb)); }
};
 
extern ClientNetworkContentSocketHandler _network_content_client;
 
void ShowNetworkContentListWindow(ContentVector *cv = nullptr, ContentType type1 = CONTENT_TYPE_END, ContentType type2 = CONTENT_TYPE_END);
 
void ShowMissingContentWindow(const struct GRFConfig *list);
 
#endif /* NETWORK_CONTENT_H */