PVRManager.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/kodi-dev-kit/include/kodi/c-api/addon-instance/pvr/pvr_general.h"
#include "interfaces/IAnnouncer.h"
#include "pvr/PVRComponentRegistration.h"
#include "pvr/epg/EpgContainer.h"
#include "pvr/guilib/PVRGUIActionListener.h"
#include "pvr/settings/PVRSettings.h"
#include "threads/CriticalSection.h"
#include "threads/Event.h"
#include "threads/Thread.h"
#include "utils/EventStream.h"

#include <memory>
#include <string>
#include <vector>

class CFileItem;
class CStopWatch;

namespace PVR
{
class CPVRChannel;
class CPVRChannelGroup;
class CPVRChannelGroupsContainer;
class CPVRProviders;
class CPVRClient;
class CPVRClients;
class CPVRDatabase;
class CPVRGUIInfo;
class CPVRGUIProgressHandler;
class CPVRManagerJobQueue;
class CPVRPlaybackState;
class CPVRRecording;
class CPVRRecordings;
class CPVRTimers;

enum class PVREvent
{
  // PVR Manager states
  ManagerError = 0,
  ManagerStopped,
  ManagerStarting,
  ManagerStopping,
  ManagerInterrupted,
  ManagerStarted,

  // Channel events
  ChannelPlaybackStopped,

  // Channel group events
  ChannelGroup,
  ChannelGroupInvalidated,
  ChannelGroupsInvalidated,
  ChannelGroupsLoaded,

  // Recording events
  RecordingsInvalidated,

  // Timer events
  AnnounceReminder,
  Timers,
  TimersInvalidated,

  // EPG events
  Epg,
  EpgActiveItem,
  EpgContainer,
  EpgItemUpdate,
  EpgUpdatePending,
  EpgDeleted,

  // Saved searches events
  SavedSearchesInvalidated,

  // Item events
  CurrentItem,

  // Syetem events
  SystemSleep,
  SystemWake,
};

class CPVRManager : private CThread, public ANNOUNCEMENT::IAnnouncer
{
public:
  CPVRManager();

  ~CPVRManager() override;

  void Announce(ANNOUNCEMENT::AnnouncementFlag flag,
                const std::string& sender,
                const std::string& message,
                const CVariant& data) override;

  template<class T>
  T& Get()
  {
    return *m_components->GetComponent<T>();
  }

  std::shared_ptr<CPVRProviders> Providers() const;

  std::shared_ptr<CPVRChannelGroupsContainer> ChannelGroups() const;

  std::shared_ptr<CPVRRecordings> Recordings() const;

  std::shared_ptr<CPVRTimers> Timers() const;

  std::shared_ptr<CPVRClients> Clients() const;

  std::shared_ptr<CPVRClient> GetClient(const CFileItem& item) const;

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

  std::shared_ptr<CPVRPlaybackState> PlaybackState() const;

  CPVREpgContainer& EpgContainer();

  void Init();

  void Start();

  void Stop(bool bRestart = false);

  void Unload();

  void Deinit();

  void OnSleep();

  void OnWake();

  std::shared_ptr<CPVRDatabase> GetTVDatabase() const;

  bool IsStarted() const { return GetState() == ManagerState::STATE_STARTED; }

  bool EpgsCreated() const;

  void OnPlaybackStarted(const CFileItem& item);

  void OnPlaybackStopped(const CFileItem& item);

  void OnPlaybackEnded(const CFileItem& item);

  void TriggerEpgsCreate();

  void TriggerRecordingsUpdate(int clientId);
  void TriggerRecordingsUpdate();

  void TriggerRecordingsSizeInProgressUpdate();

  void TriggerTimersUpdate(int clientId);
  void TriggerTimersUpdate();

  void TriggerChannelsUpdate(int clientId);
  void TriggerChannelsUpdate();

  void TriggerProvidersUpdate(int clientId);
  void TriggerProvidersUpdate();

  void TriggerChannelGroupsUpdate(int clientId);
  void TriggerChannelGroupsUpdate();

  void TriggerSearchMissingChannelIcons();

  void TriggerCleanupCachedImages();

  void TriggerSearchMissingChannelIcons(const std::shared_ptr<CPVRChannelGroup>& group);

  void LocalizationChanged();

  bool IsParentalLocked(const std::shared_ptr<CPVRChannel>& channel) const;

  bool IsParentalLocked(const std::shared_ptr<CPVREpgInfoTag>& epgTag) const;

  void RestartParentalTimer();

  bool CreateChannelEpgs();

  void ConnectionStateChange(CPVRClient* client,
                             const std::string& connectString,
                             PVR_CONNECTION_STATE state,
                             const std::string& message);

  CEventStream<PVREvent>& Events() { return m_events; }

  void PublishEvent(PVREvent state);

protected:
  void Process() override;

private:
  bool SetWakeupCommand();

  enum class ManagerState
  {
    STATE_ERROR = 0,
    STATE_STOPPED,
    STATE_STARTING,
    STATE_SSTOPPING,
    STATE_INTERRUPTED,
    STATE_STARTED
  };

  bool IsInitialising() const { return GetState() == ManagerState::STATE_STARTING; }

  bool IsStopped() const { return GetState() == ManagerState::STATE_STOPPED; }

  ManagerState GetState() const;

  void SetState(ManagerState state);

  void UpdateComponents(ManagerState stateToCheck);

  bool UpdateComponents(ManagerState stateToCheck,
                        const std::unique_ptr<CPVRGUIProgressHandler>& progressHandler);

  void UnloadComponents();

  bool IsKnownClient(int clientID) const;

  void ResetProperties();

  void Clear();

  void TriggerPlayChannelOnStartup();

  bool IsCurrentlyParentalLocked(const std::shared_ptr<CPVRChannel>& channel,
                                 bool bGenerallyLocked) const;

  CEventSource<PVREvent> m_events;

  std::shared_ptr<CPVRProviders> m_providers; 
  std::shared_ptr<CPVRChannelGroupsContainer>
      m_channelGroups; 
  std::shared_ptr<CPVRRecordings> m_recordings; 
  std::shared_ptr<CPVRTimers> m_timers; 
  std::shared_ptr<CPVRClients> m_addons; 
  std::unique_ptr<CPVRGUIInfo> m_guiInfo; 
  std::shared_ptr<CPVRComponentRegistration> m_components; 
  CPVREpgContainer m_epgContainer; 

  std::vector<std::shared_ptr<CPVRClient>> m_knownClients; 
  std::unique_ptr<CPVRManagerJobQueue> m_pendingUpdates; 
  std::shared_ptr<CPVRDatabase> m_database; 
  mutable CCriticalSection
      m_critSection; 
  bool m_bFirstStart = true; 
  bool m_bEpgsCreated = false; 
  mutable CCriticalSection m_managerStateMutex;
  ManagerState m_managerState = ManagerState::STATE_STOPPED;
  std::unique_ptr<CStopWatch> m_parentalTimer;

  CCriticalSection
      m_startStopMutex; // mutex for protecting pvr manager's start/restart/stop sequence */

  const std::shared_ptr<CPVRPlaybackState> m_playbackState;
  CPVRGUIActionListener m_actionListener;
  CPVRSettings m_settings;
};
} // namespace PVR