AddonInfo.h

/*
 *  Copyright (C) 2005-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */

#pragma once

#include "XBDateTime.h"
#include "addons/AddonVersion.h"

#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

namespace ADDON
{

enum class AddonType;

class CAddonBuilder;
class CAddonInfo;
class CAddonType;
typedef std::shared_ptr<CAddonInfo> AddonInfoPtr;
typedef std::vector<AddonInfoPtr> AddonInfos;

using AddonInstanceId = uint32_t;

constexpr const char* KODI_ADDON_DEFAULT_LANGUAGE_CODE = "en_GB";

enum class AddonDisabledReason
{
  NONE = 0,
  USER = 1,
  INCOMPATIBLE = 2,
  PERMANENT_FAILURE = 3
};

enum class AddonOriginType
{
  SYSTEM = 0, 
  REPOSITORY = 1, 
  MANUAL = 2 
};

enum class AddonUpdateRule
{
  ANY = 0, 
  USER_DISABLED_AUTO_UPDATE = 1, 
  PIN_OLD_VERSION = 2, 
  PIN_ZIP_INSTALL = 3, 
};

enum class AddonInstanceSupport
{
  SUPPORT_NONE = 0,

  SUPPORT_MANDATORY = 1,

  SUPPORT_OPTIONAL = 2,

  SUPPORT_SETTINGS = 3,
};

enum class AddonLifecycleState
{
  NORMAL = 0, 
  DEPRECATED = 1, 
  BROKEN = 2, 
};

struct DependencyInfo
{
  std::string id;
  CAddonVersion versionMin, version;
  bool optional;
  DependencyInfo(std::string id,
                 const CAddonVersion& versionMin,
                 const CAddonVersion& version,
                 bool optional)
    : id(std::move(id)),
      versionMin(versionMin.empty() ? version : versionMin),
      version(version),
      optional(optional)
  {
  }

  bool operator==(const DependencyInfo& rhs) const
  {
    return id == rhs.id && versionMin == rhs.versionMin && version == rhs.version &&
           optional == rhs.optional;
  }

  bool operator!=(const DependencyInfo& rhs) const
  {
    return !(rhs == *this);
  }
};

typedef std::map<std::string, std::string> InfoMap;
typedef std::map<std::string, std::string> ArtMap;

class CAddonInfoBuilder;

class CAddonInfo
{
public:
  CAddonInfo() = default;
  CAddonInfo(std::string id, AddonType type);

  void SetMainType(AddonType type) { m_mainType = type; }
  void SetBinary(bool isBinary) { m_isBinary = isBinary; }
  void SetLibName(const std::string& libname) { m_libname = libname; }
  void SetPath(const std::string& path) { m_path = path; }
  void AddExtraInfo(const std::string& idName, const std::string& value) { m_extrainfo[idName] = value; }
  void SetLastUsed(const CDateTime& dateTime) { m_lastUsed = dateTime; }

  const std::string& ID() const { return m_id; }

  AddonType MainType() const { return m_mainType; }

  bool HasType(AddonType type, bool mainOnly = false) const;

  const std::vector<CAddonType>& Types() const { return m_types; }

  const CAddonType* Type(AddonType type) const;

  bool ProvidesSubContent(AddonType content, AddonType mainType) const;
  bool ProvidesSeveralSubContents() const;

  const CAddonVersion& Version() const { return m_version; }
  const CAddonVersion& MinVersion() const { return m_minversion; }
  bool IsBinary() const { return m_isBinary; }
  const CAddonVersion& DependencyMinVersion(const std::string& dependencyID) const;
  const CAddonVersion& DependencyVersion(const std::string& dependencyID) const;
  const std::string& Name() const { return m_name; }
  const std::string& License() const { return m_license; }
  const std::string& Summary() const { return GetTranslatedText(m_summary); }
  const std::string& Description() const { return GetTranslatedText(m_description); }
  const std::string& LibName() const { return m_libname; }
  const std::string& Author() const { return m_author; }
  const std::string& Source() const { return m_source; }
  const std::string& Website() const { return m_website; }
  const std::string& Forum() const { return m_forum; }
  const std::string& EMail() const { return m_email; }
  const std::string& Path() const { return m_path; }
  const std::string& ProfilePath() const { return m_profilePath; }
  const std::string& ChangeLog() const { return GetTranslatedText(m_changelog); }
  const std::string& Icon() const { return m_icon; }
  const ArtMap& Art() const { return m_art; }
  const std::vector<std::string>& Screenshots() const { return m_screenshots; }
  const std::string& Disclaimer() const { return GetTranslatedText(m_disclaimer); }
  const std::vector<DependencyInfo>& GetDependencies() const { return m_dependencies; }
  AddonLifecycleState LifecycleState() const { return m_lifecycleState; }
  const std::string& LifecycleStateDescription() const
  {
    return GetTranslatedText(m_lifecycleStateDescription);
  }
  const std::string& Origin() const { return m_origin; }
  const std::string& OriginName() const;

  const InfoMap& ExtraInfo() const { return m_extrainfo; }

  bool MeetsVersion(const CAddonVersion& versionMin, const CAddonVersion& version) const;
  uint64_t PackageSize() const { return m_packageSize; }
  CDateTime InstallDate() const { return m_installDate; }
  CDateTime LastUpdated() const { return m_lastUpdated; }
  CDateTime LastUsed() const { return m_lastUsed; }

  bool SupportsMultipleInstances() const;
  AddonInstanceSupport InstanceUseType() const { return m_addonInstanceSupportType; }

  bool SupportsAddonSettings() const { return m_supportsAddonSettings; }
  bool SupportsInstanceSettings() const { return m_supportsInstanceSettings; }
  std::vector<AddonInstanceId> GetKnownInstanceIds() const;

  static std::string TranslateType(AddonType type, bool pretty = false);
  static std::string TranslateIconType(AddonType type);
  static AddonType TranslateType(const std::string& string);
  static AddonType TranslateSubContent(const std::string& content);
  static AddonInstanceSupport InstanceSupportType(AddonType type);

private:
  friend class CAddonInfoBuilder;
  friend class CAddonInfoBuilderFromDB;

  std::string m_id;
  AddonType m_mainType{};
  std::vector<CAddonType> m_types;

  CAddonVersion m_version;
  CAddonVersion m_minversion;
  bool m_isBinary = false;
  std::string m_name;
  std::string m_license;
  std::unordered_map<std::string, std::string> m_summary;
  std::unordered_map<std::string, std::string> m_description;
  std::string m_author;
  std::string m_source;
  std::string m_website;
  std::string m_forum;
  std::string m_email;
  std::string m_path;
  std::string m_profilePath;
  std::unordered_map<std::string, std::string> m_changelog;
  std::string m_icon;
  ArtMap m_art;
  std::vector<std::string> m_screenshots;
  std::unordered_map<std::string, std::string> m_disclaimer;
  std::vector<DependencyInfo> m_dependencies;
  AddonLifecycleState m_lifecycleState = AddonLifecycleState::NORMAL;
  std::unordered_map<std::string, std::string> m_lifecycleStateDescription;
  CDateTime m_installDate;
  CDateTime m_lastUpdated;
  CDateTime m_lastUsed;
  std::string m_origin;
  mutable std::unique_ptr<std::string> m_originName; // @todo use std::optional once we use c++17
  uint64_t m_packageSize = 0;
  std::string m_libname;
  InfoMap m_extrainfo;
  std::vector<std::string> m_platforms;
  AddonInstanceSupport m_addonInstanceSupportType{AddonInstanceSupport::SUPPORT_NONE};
  bool m_supportsAddonSettings{false};
  bool m_supportsInstanceSettings{false};

  const std::string& GetTranslatedText(const std::unordered_map<std::string, std::string>& locales) const;
};

} /* namespace ADDON */