content_manager.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <map>
#include <memory>
#include <unordered_map>
#include <vector>
#include <format>
#include <string>
#include <filesystem>
#include <optional>
#include <string_view>
#include <functional>
#include <span>
 
#include <rex/platform.h>
#include <rex/types.h>
#include <rex/memory.h>
#include <rex/kernel/types/status.h>
#include <rex/memory/stream.h>
#include <rex/kernel/types/content.h>
#include <rex/result.h>
#include <rex/utility.h>
#include <rex/title.h>
 
namespace rex::xam {

struct PackageInfo {
  u32 title_id = 0;
  kernel::XContentType content_type = kernel::XContentType::kInvalid;
  std::map<kernel::XLanguage, std::u16string> display_names; 
  std::u16string description;                                
  std::u16string publisher;
  std::array<u8, 20> content_id{}; 
  u32 license_mask = 0;            
  std::vector<u8> thumbnail;       
};

struct InstallOptions {
  bool require_running_title = true;
  bool extract = true;
};

struct InstalledPackage {
  kernel::XCONTENT_AGGREGATE_DATA data;
  PackageInfo info;
  bool enabled = true;   
  bool in_place = false; 
};
 
class IContentManager : public NonCopyable {
 public:
  virtual ~IContentManager() = default;

  [[nodiscard]] virtual std::vector<kernel::XCONTENT_AGGREGATE_DATA> ListContent(
      u32 device_id, u64 xuid, rex::kernel::XContentType content_type,
      u32 title_id = 0xFFFFFFFF) = 0;
 
  [[nodiscard]] virtual bool HasContent(u64 xuid, const kernel::XCONTENT_AGGREGATE_DATA& data) = 0;

  [[nodiscard]] virtual Result<void> CreateContent(std::string_view root_name, u64 xuid,
                                                   const kernel::XCONTENT_AGGREGATE_DATA& data) = 0;

  [[nodiscard]] virtual Result<u32> OpenContent(std::string_view root_name, u64 xuid,
                                                const kernel::XCONTENT_AGGREGATE_DATA& data) = 0;

  [[nodiscard]] virtual Result<void> CloseContent(std::string_view root_name) = 0;

  [[nodiscard]] virtual Result<std::vector<u8>> GetContentThumbnail(
      u64 xuid, const kernel::XCONTENT_AGGREGATE_DATA& data) = 0;

  [[nodiscard]] virtual Result<void> SetContentThumbnail(
      u64 xuid, const kernel::XCONTENT_AGGREGATE_DATA& data, std::vector<u8> buffer) = 0;

  [[nodiscard]] virtual Result<void> DeleteContent(u64 xuid,
                                                   const kernel::XCONTENT_AGGREGATE_DATA& data) = 0;

  [[nodiscard]] virtual Result<void> WriteContentHeaderFile(u64 xuid,
                                                            kernel::XCONTENT_AGGREGATE_DATA data,
                                                            u32 license_mask = 0) = 0;

  [[nodiscard]] virtual Result<kernel::XCONTENT_AGGREGATE_DATA> ReadContentHeaderFile(
      std::string_view file_name, u64 xuid, u32 title_id,
      rex::kernel::XContentType content_type) const = 0;

  [[nodiscard]] virtual std::filesystem::path ResolveGameUserContentPath() = 0;
 
  [[nodiscard]] virtual bool IsContentOpen(const kernel::XCONTENT_AGGREGATE_DATA& data) const = 0;

  virtual void CloseOpenedFilesFromContent(std::string_view root_name) = 0;

  [[nodiscard]] virtual Result<PackageInfo> InspectPackage(
      const std::filesystem::path& package_path) const = 0;

  [[nodiscard]] virtual Result<kernel::XCONTENT_AGGREGATE_DATA> InstallContent(
      const std::filesystem::path& package_path, const InstallOptions& options = {}) = 0;

  [[nodiscard]] virtual Result<void> SetContentEnabled(const kernel::XCONTENT_AGGREGATE_DATA& data,
                                                       bool enabled,
                                                       std::optional<u64> xuid = std::nullopt) = 0;

  [[nodiscard]] virtual std::vector<InstalledPackage> ListInstalledPackages(
      u32 title_id = kernel::kRunningTitleID) const = 0;

  [[nodiscard]] virtual rex::ScopeGuard OnContentChanged(
      rex::MoveOnlyFunction<void()> callback) = 0;

  [[nodiscard]] virtual Result<u32> GetContentDeviceID(std::string_view root_name) const = 0;
};
 
}  // namespace rex::xam