PVRClients.h

/*
 *  Copyright (C) 2012-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 "addons/IAddonManagerCallback.h"
#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/pvr/pvr_general.h"
#include "threads/CriticalSection.h"

#include <functional>
#include <map>
#include <memory>
#include <string>
#include <vector>

class CVariant;

namespace ADDON
{
  struct AddonEvent;
  class CAddonInfo;
}

namespace PVR
{
class CPVRChannel;
class CPVRChannelGroup;
class CPVRChannelGroupMember;
class CPVRChannelGroups;
class CPVRProvidersContainer;
class CPVRClient;
class CPVREpg;
class CPVRRecordings;
class CPVRTimerType;
class CPVRTimersContainer;

typedef std::map<int, std::shared_ptr<CPVRClient>> CPVRClientMap;

struct SBackend
{
  std::string name;
  std::string version;
  std::string host;
  int numTimers = 0;
  int numRecordings = 0;
  int numDeletedRecordings = 0;
  int numProviders = 0;
  int numChannelGroups = 0;
  int numChannels = 0;
  uint64_t diskUsed = 0;
  uint64_t diskTotal = 0;
};

  class CPVRClients : public ADDON::IAddonMgrCallback
  {
  public:
    CPVRClients();
    ~CPVRClients() override;

    void Start();

    void Stop();

    void Continue();

    void UpdateClients(
        const std::string& changedAddonId = "",
        ADDON::AddonInstanceId changedInstanceId = ADDON::ADDON_SINGLETON_INSTANCE_ID);

    bool RequestRestart(const std::string& addonId,
                        ADDON::AddonInstanceId instanceId,
                        bool bDataChanged) override;

    bool StopClient(int clientId, bool restart);

    void OnAddonEvent(const ADDON::AddonEvent& event);

    int CreatedClientAmount() const;

    bool HasCreatedClients() const;

    bool IsCreatedClient(int iClientId) const;

    std::shared_ptr<CPVRClient> GetCreatedClient(int clientId) const;

    CPVRClientMap GetCreatedClients() const;

    int GetFirstCreatedClientID();

    bool HasIgnoredClients() const;

    int EnabledClientAmount() const;

    bool IsEnabledClient(int clientId) const;

    std::vector<CVariant> GetEnabledClientInfos() const;

    std::vector<CVariant> GetClientProviderInfos() const;



    std::vector<SBackend> GetBackendProperties() const;



    bool GetTimers(const std::vector<std::shared_ptr<CPVRClient>>& clients,
                   CPVRTimersContainer* timers,
                   std::vector<int>& failedClients);

    PVR_ERROR UpdateTimerTypes(const std::vector<std::shared_ptr<CPVRClient>>& clients,
                               std::vector<int>& failedClients);

    const std::vector<std::shared_ptr<CPVRTimerType>> GetTimerTypes() const;



    PVR_ERROR GetRecordings(const std::vector<std::shared_ptr<CPVRClient>>& clients,
                            CPVRRecordings* recordings,
                            bool deleted,
                            std::vector<int>& failedClients);

    PVR_ERROR DeleteAllRecordingsFromTrash();



    PVR_ERROR SetEPGMaxPastDays(int iPastDays);

    PVR_ERROR SetEPGMaxFutureDays(int iFutureDays);



    PVR_ERROR GetChannels(const std::vector<std::shared_ptr<CPVRClient>>& clients,
                          bool bRadio,
                          std::vector<std::shared_ptr<CPVRChannel>>& channels,
                          std::vector<int>& failedClients);

    PVR_ERROR GetProviders(const std::vector<std::shared_ptr<CPVRClient>>& clients,
                           CPVRProvidersContainer* providers,
                           std::vector<int>& failedClients);

    PVR_ERROR GetChannelGroups(const std::vector<std::shared_ptr<CPVRClient>>& clients,
                               CPVRChannelGroups* groups,
                               std::vector<int>& failedClients);

    PVR_ERROR GetChannelGroupMembers(
        const std::vector<std::shared_ptr<CPVRClient>>& clients,
        CPVRChannelGroup* group,
        std::vector<std::shared_ptr<CPVRChannelGroupMember>>& groupMembers,
        std::vector<int>& failedClients);

    std::vector<std::shared_ptr<CPVRClient>> GetClientsSupportingChannelScan() const;

    std::vector<std::shared_ptr<CPVRClient>> GetClientsSupportingChannelSettings(bool bRadio) const;

    bool AnyClientSupportingRecordingsSize() const;

    bool AnyClientSupportingEPG() const;

    bool AnyClientSupportingRecordings() const;

    bool AnyClientSupportingRecordingsDelete() const;


    void OnSystemSleep();

    void OnSystemWake();

    void OnPowerSavingActivated();

    void OnPowerSavingDeactivated();


    void ConnectionStateChange(CPVRClient* client,
                               const std::string& strConnectionString,
                               PVR_CONNECTION_STATE newState,
                               const std::string& strMessage);

  private:
    std::vector<ADDON::AddonInstanceId> GetKnownInstanceIds(const std::string& addonID) const;

    bool GetAddonsWithStatus(
        const std::string& changedAddonId,
        std::vector<std::pair<std::shared_ptr<ADDON::CAddonInfo>, bool>>& addonsWithStatus) const;

    std::vector<std::pair<ADDON::AddonInstanceId, bool>> GetInstanceIdsWithStatus(
        const std::shared_ptr<ADDON::CAddonInfo>& addon, bool addonIsEnabled) const;

    std::shared_ptr<CPVRClient> GetClient(int clientId) const;

    bool IsKnownClient(int iClientId) const;

    PVR_ERROR GetCallableClients(CPVRClientMap& clientsReady,
                                 std::vector<int>& clientsNotReady) const;

    typedef std::function<PVR_ERROR(const std::shared_ptr<CPVRClient>&)> PVRClientFunction;

    PVR_ERROR ForClients(const char* strFunctionName,
                         const std::vector<std::shared_ptr<CPVRClient>>& clients,
                         const PVRClientFunction& function,
                         std::vector<int>& failedClients) const;

    PVR_ERROR ForCreatedClients(const char* strFunctionName,
                                const PVRClientFunction& function) const;

    PVR_ERROR ForCreatedClients(const char* strFunctionName,
                                const PVRClientFunction& function,
                                std::vector<int>& failedClients) const;

    mutable CCriticalSection m_critSection;
    CPVRClientMap m_clientMap;
  };
}