AddonManager.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 "threads/CriticalSection.h"
#include "utils/EventStream.h"

#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <string>
#include <vector>

namespace ADDON
{
enum class AddonDisabledReason;
enum class AddonOriginType;
enum class AddonType;
enum class AddonUpdateRule;
enum class AllowCheckForUpdates : bool;

class CAddonDatabase;
class CAddonUpdateRules;
class CAddonVersion;
class IAddonMgrCallback;

class CAddonInfo;
using AddonInfoPtr = std::shared_ptr<CAddonInfo>;
using ADDON_INFO_LIST = std::map<std::string, AddonInfoPtr>;

class IAddon;
using AddonPtr = std::shared_ptr<IAddon>;
using VECADDONS = std::vector<AddonPtr>;

struct AddonEvent;
struct AddonWithUpdate;
struct DependencyInfo;
struct RepositoryDirInfo;

using AddonInstanceId = uint32_t;

enum class AddonCheckType : bool
{
  OUTDATED_ADDONS,
  AVAILABLE_UPDATES,
};

enum class OnlyEnabled : bool
{
  CHOICE_YES = true,
  CHOICE_NO = false,
};

enum class OnlyEnabledRootAddon : bool
{
  CHOICE_YES = true,
  CHOICE_NO = false,
};

enum class CheckIncompatible : bool
{
  CHOICE_YES = true,
  CHOICE_NO = false,
};

class CAddonMgr
{
public:
  bool ReInit()
  {
    DeInit();
    return Init();
  }
  bool Init();
  void DeInit();

  CAddonMgr();
  CAddonMgr(const CAddonMgr&) = delete;
  virtual ~CAddonMgr();

  CEventStream<AddonEvent>& Events() { return m_events; }
  CEventStream<AddonEvent>& UnloadEvents() { return m_unloadEvents; }

  IAddonMgrCallback* GetCallbackForType(AddonType type);
  bool RegisterAddonMgrCallback(AddonType type, IAddonMgrCallback* cb);
  void UnregisterAddonMgrCallback(AddonType type);

  bool GetAddon(const std::string& id,
                AddonPtr& addon,
                AddonType type,
                OnlyEnabled onlyEnabled) const;

  bool GetAddon(const std::string& id, AddonPtr& addon, OnlyEnabled onlyEnabled) const;

  bool HasType(const std::string& id, AddonType type);

  bool HasAddons(AddonType type);

  bool HasInstalledAddons(AddonType type);

  bool GetAddonsForUpdate(VECADDONS& addons) const;

  bool GetAddons(VECADDONS& addons) const;

  bool GetAddons(VECADDONS& addons, AddonType type);

  bool GetInstalledAddons(VECADDONS& addons);

  bool GetInstalledAddons(VECADDONS& addons, AddonType type);

  bool GetDisabledAddons(VECADDONS& addons);

  bool GetDisabledAddons(VECADDONS& addons, AddonType type);

  bool GetInstallableAddons(VECADDONS& addons);

  bool GetInstallableAddons(VECADDONS& addons, AddonType type);

  bool FindInstallableById(const std::string& addonId, AddonPtr& addon);

  void AddToUpdateableAddons(AddonPtr& pAddon);
  void RemoveFromUpdateableAddons(AddonPtr& pAddon);
  bool ReloadSettings(const std::string& addonId, AddonInstanceId instanceId);

  std::vector<std::shared_ptr<IAddon>> GetAvailableUpdates() const;

  std::vector<std::shared_ptr<IAddon>> GetOutdatedAddons() const;

  bool HasAvailableUpdates();

  bool IsOrphaned(const std::shared_ptr<IAddon>& addon,
                  const std::vector<std::shared_ptr<IAddon>>& allAddons) const;

  bool FindAddons();

  bool FindAddon(const std::string& addonId,
                 const std::string& origin,
                 const CAddonVersion& addonVersion);

  bool GetIncompatibleEnabledAddonInfos(std::vector<AddonInfoPtr>& incompatible) const;

  std::vector<AddonInfoPtr> MigrateAddons();

  std::vector<AddonInfoPtr> DisableIncompatibleAddons(
      const std::vector<AddonInfoPtr>& incompatible);

  void CheckAndInstallAddonUpdates(bool wait) const;

  bool UnloadAddon(const std::string& addonId);

  bool LoadAddon(const std::string& addonId,
                 const std::string& origin,
                 const CAddonVersion& addonVersion);

  void OnPostUnInstall(const std::string& id);

  bool DisableAddon(const std::string& ID, AddonDisabledReason disabledReason);

  bool UpdateDisabledReason(const std::string& id, AddonDisabledReason newDisabledReason);

  bool EnableAddon(const std::string& ID);

  /* \brief Check whether an addon has been disabled via DisableAddon.
     In case the disabled cache does not know about the current state the database routine will be used.
     \param ID id of the addon
     \sa DisableAddon
     */
  bool IsAddonDisabled(const std::string& ID) const;

  bool IsAddonDisabledExcept(const std::string& ID, AddonDisabledReason disabledReason) const;

  /* \brief Checks whether an addon can be disabled via DisableAddon.
     \param ID id of the addon
     \sa DisableAddon
     */
  bool CanAddonBeDisabled(const std::string& ID);

  bool CanAddonBeEnabled(const std::string& id);

  /* \brief Checks whether an addon is installed.
     \param ID id of the addon
    */
  bool IsAddonInstalled(const std::string& ID);

  /* \brief Checks whether an addon is installed from a
     *        particular origin repo
     * \note if checked for an origin defined as official (i.e. repository.xbmc.org)
     *       this function will return true even if the addon is a shipped system add-on
     * \param ID id of the addon
     * \param origin origin repository id
     */
  bool IsAddonInstalled(const std::string& ID, const std::string& origin) const;

  /* \brief Checks whether an addon is installed from a
     *        particular origin repo and version
     * \note if checked for an origin defined as official (i.e. repository.xbmc.org)
     *       this function will return true even if the addon is a shipped system add-on
     * \param ID id of the addon
     * \param origin origin repository id
     * \param version the version of the addon
     */
  bool IsAddonInstalled(const std::string& ID,
                        const std::string& origin,
                        const CAddonVersion& version);

  /* \brief Checks whether an addon can be installed. Broken addons can't be installed.
    \param addon addon to be checked
    */
  bool CanAddonBeInstalled(const AddonPtr& addon);

  bool CanUninstall(const AddonPtr& addon);

  bool IsBundledAddon(const std::string& id);

  bool IsSystemAddon(const std::string& id);

  bool IsRequiredSystemAddon(const std::string& id);

  bool IsOptionalSystemAddon(const std::string& id);


  /* \brief Add a single update rule to the list for an addon
     * \sa CAddonUpdateRules::AddUpdateRuleToList()
     */
  bool AddUpdateRuleToList(const std::string& id, AddonUpdateRule updateRule);

  /* \brief Remove all rules from update rules list for an addon
     * \sa CAddonUpdateRules::RemoveAllUpdateRulesFromList()
     */
  bool RemoveAllUpdateRulesFromList(const std::string& id);

  /* \brief Remove a specific rule from update rules list for an addon
     * \sa CAddonUpdateRules::RemoveUpdateRuleFromList()
     */
  bool RemoveUpdateRuleFromList(const std::string& id, AddonUpdateRule updateRule);

  /* \brief Check if an addon version is auto-updateable
     * \param id addon id to be checked
     * \return true is addon is auto-updateable, false otherwise
     * \sa CAddonUpdateRules::IsAutoUpdateable()
     */
  bool IsAutoUpdateable(const std::string& id) const;

  /* \brief Launches event AddonEvent::AutoUpdateStateChanged
     * \param id addon id to pass through
     * \sa CGUIDialogAddonInfo::OnToggleAutoUpdates()
     */
  void PublishEventAutoUpdateStateChanged(const std::string& id);
  void UpdateLastUsed(const std::string& id);

  void PublishInstanceAdded(const std::string& addonId, AddonInstanceId instanceId);

  void PublishInstanceRemoved(const std::string& addonId, AddonInstanceId instanceId);

  bool LoadAddonDescription(const std::string& path, AddonPtr& addon);

  bool ServicesHasStarted() const;

  bool IsCompatible(const IAddon& addon) const;

  bool IsCompatible(const AddonInfoPtr& addonInfo) const;

  std::vector<DependencyInfo> GetDepsRecursive(const std::string& id,
                                               OnlyEnabledRootAddon onlyEnabledRootAddon);

  bool GetAddonInfos(std::vector<AddonInfoPtr>& addonInfos, bool onlyEnabled, AddonType type) const;

  std::vector<AddonInfoPtr> GetAddonInfos(bool onlyEnabled,
                                          const std::vector<AddonType>& types) const;

  bool GetDisabledAddonInfos(std::vector<AddonInfoPtr>& addonInfos, AddonType type) const;

  bool GetDisabledAddonInfos(std::vector<AddonInfoPtr>& addonInfos,
                             AddonType type,
                             AddonDisabledReason disabledReason) const;

  const AddonInfoPtr GetAddonInfo(const std::string& id, AddonType type) const;

  const std::string& GetTempAddonBasePath() { return m_tempAddonBasePath; }

  AddonOriginType GetAddonOriginType(const AddonPtr& addon) const;

  bool IsAddonDisabledWithReason(const std::string& ID, AddonDisabledReason disabledReason) const;


  bool SetAddonOrigin(const std::string& addonId, const std::string& repoAddonId, bool isUpdate);

  bool AddonsFromRepoXML(const RepositoryDirInfo& repo,
                         const std::string& xml,
                         std::vector<AddonInfoPtr>& addons);

  std::map<std::string, AddonWithUpdate> GetAddonsWithAvailableUpdate() const;

  std::vector<std::shared_ptr<IAddon>> GetCompatibleVersions(const std::string& addonId) const;

  const std::string& GetLastAvailableUpdatesCountAsString() const;

  std::vector<std::shared_ptr<IAddon>> GetOrphanedDependencies() const;

private:
  CAddonMgr& operator=(CAddonMgr const&) = delete;

  VECADDONS m_updateableAddons;

  std::vector<std::shared_ptr<IAddon>> GetAvailableUpdatesOrOutdatedAddons(
      AddonCheckType addonCheckType) const;

  bool GetAddonsInternal(AddonType type,
                         VECADDONS& addons,
                         OnlyEnabled onlyEnabled,
                         CheckIncompatible checkIncompatible) const;

  bool EnableSingle(const std::string& id);

  void FindAddons(ADDON_INFO_LIST& addonmap, const std::string& path);

  bool GetIncompatibleAddonInfos(std::vector<AddonInfoPtr>& incompatible,
                                 bool includeDisabled) const;

  bool GetAddonUpdateCandidates(VECADDONS& updates) const;

  void SortByDependencies(VECADDONS& updates) const;

  void InstallAddonUpdates(VECADDONS& updates,
                           bool wait,
                           AllowCheckForUpdates allowCheckForUpdates) const;

  // This guards the addon installation process to make sure
  // addon updates are not installed concurrently
  // while the migration is running. Addon updates can be triggered
  // as a result of a repository update event.
  // (migration will install any available update anyway)
  mutable std::mutex m_installAddonsMutex;

  std::map<std::string, AddonDisabledReason> m_disabled;
  static std::map<AddonType, IAddonMgrCallback*> m_managers;
  mutable CCriticalSection m_critSection;
  std::unique_ptr<CAddonDatabase> m_database;
  std::unique_ptr<CAddonUpdateRules> m_updateRules;
  CEventSource<AddonEvent> m_events;
  CBlockingEventSource<AddonEvent> m_unloadEvents;
  std::set<std::string> m_systemAddons;
  std::set<std::string> m_optionalSystemAddons;
  ADDON_INFO_LIST m_installedAddons;

  // Temporary path given to add-ons, whose content is deleted when Kodi is stopped
  const std::string m_tempAddonBasePath = "special://temp/addons";

  mutable std::string m_lastAvailableUpdatesCountAsString;
  mutable std::mutex m_lastAvailableUpdatesCountMutex;
};

}; /* namespace ADDON */