PVRChannel.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_channels.h"
#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/pvr/pvr_providers.h"
#include "pvr/PVRCachedImage.h"
#include "pvr/channels/PVRChannelNumber.h"
#include "threads/CriticalSection.h"
#include "utils/ISerializable.h"
#include "utils/ISortable.h"

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

class CDateTime;

namespace PVR
{
enum class PVREvent;

class CPVRProvider;
class CPVREpg;
class CPVREpgInfoTag;
class CPVRRadioRDSInfoTag;

class CPVRChannel : public ISerializable, public ISortable
{
  friend class CPVRDatabase;

public:
  static const std::string IMAGE_OWNER_PATTERN;

  explicit CPVRChannel(bool bRadio);
  CPVRChannel(bool bRadio, const std::string& iconPath);
  CPVRChannel(const PVR_CHANNEL& channel, unsigned int iClientId);

  virtual ~CPVRChannel();

  bool operator==(const CPVRChannel& right) const;
  bool operator!=(const CPVRChannel& right) const;

  void FillAddonData(PVR_CHANNEL& channel) const;

  void Serialize(CVariant& value) const override;


  bool QueueDelete();

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

  bool Persist();

  int ChannelID() const;

  bool IsNew() const;

  bool SetChannelID(int iDatabaseId);

  bool IsRadio() const { return m_bIsRadio; }

  bool IsHidden() const;

  bool SetHidden(bool bIsHidden, bool bIsUserSetHidden = false);

  bool IsLocked() const;

  bool SetLocked(bool bIsLocked);

  std::shared_ptr<CPVRRadioRDSInfoTag> GetRadioRDSInfoTag() const;

  void SetRadioRDSInfoTag(const std::shared_ptr<CPVRRadioRDSInfoTag>& tag);

  bool HasArchive() const;

  bool SetArchive(bool bHasArchive);

  std::string ClientIconPath() const;

  std::string IconPath() const;

  bool IsUserSetIcon() const;

  bool IsUserSetName() const;

  bool IsUserSetHidden() const;

  int LastWatchedGroupId() const;

  bool SetIconPath(const std::string& strIconPath, bool bIsUserSetIcon = false);

  std::string ChannelName() const;

  bool SetChannelName(const std::string& strChannelName, bool bIsUserSetName = false);

  time_t LastWatched() const;

  bool SetLastWatched(time_t lastWatched, int groupId);

  bool IsChanged() const;

  void Persisted();


  int UniqueID() const;

  int ClientID() const;

  bool SetClientID(int iClientId);

  const CPVRChannelNumber& ClientChannelNumber() const;

  std::string ClientChannelName() const;

  std::string MimeType() const;

  // ISortable implementation
  void ToSortable(SortItem& sortable, Field field) const override;

  std::pair<int, int> StorageId() const { return std::make_pair(m_iClientId, m_iUniqueId); }

  bool IsEncrypted() const;

  int EncryptionSystem() const;

  std::string EncryptionName() const;


  int EpgID() const;

  bool CreateEPG();

  std::shared_ptr<CPVREpg> GetEPG() const;

  std::vector<std::shared_ptr<CPVREpgInfoTag>> GetEpgTags() const;

  std::vector<std::shared_ptr<CPVREpgInfoTag>> GetEPGTimeline(const CDateTime& timelineStart,
                                                              const CDateTime& timelineEnd,
                                                              const CDateTime& minEventEnd,
                                                              const CDateTime& maxEventStart) const;

  std::shared_ptr<CPVREpgInfoTag> CreateEPGGapTag(const CDateTime& start,
                                                  const CDateTime& end) const;

  std::shared_ptr<CPVREpgInfoTag> GetEPGNow() const;

  std::shared_ptr<CPVREpgInfoTag> GetEPGPrevious() const;

  std::shared_ptr<CPVREpgInfoTag> GetEPGNext() const;

  bool EPGEnabled() const;

  bool SetEPGEnabled(bool bEPGEnabled);

  std::string EPGScraper() const;

  bool SetEPGScraper(const std::string& strScraper);

  bool CanRecord() const;

  static std::string GetEncryptionName(int iCaid);

  int ClientOrder() const { return m_iClientOrder; }

  int ClientProviderUid() const { return m_iClientProviderUid; }

  void Notify(const PVREvent& event);

  void Lock() { m_critSection.lock(); }

  void Unlock() { m_critSection.unlock(); }

  std::shared_ptr<CPVRProvider> GetDefaultProvider() const;

  bool HasClientProvider() const;

  std::shared_ptr<CPVRProvider> GetProvider() const;

private:
  CPVRChannel() = delete;
  CPVRChannel(const CPVRChannel& tag) = delete;
  CPVRChannel& operator=(const CPVRChannel& channel) = delete;

  void UpdateEncryptionName();

  void ResetEPG();

  bool SetClientProviderUid(int iClientProviderUid);

  int m_iChannelId = -1; 
  bool m_bIsRadio = false; 
  bool m_bIsHidden = false; 
  bool m_bIsUserSetName = false; 
  bool m_bIsUserSetIcon = false; 
  bool m_bIsUserSetHidden = false; 
  bool m_bIsLocked = false; 
  CPVRCachedImage m_iconPath; 
  std::string m_strChannelName; 
  time_t m_iLastWatched = 0; 
  bool m_bChanged =
      false; 
  std::shared_ptr<CPVRRadioRDSInfoTag>
      m_rdsTag; 
  bool m_bHasArchive = false; 

  int m_iEpgId = -1; 
  bool m_bEPGEnabled = false; 
  std::string m_strEPGScraper =
      "client"; 
  std::shared_ptr<CPVREpg> m_epg;

  int m_iUniqueId = -1; 
  int m_iClientId = -1; 
  CPVRChannelNumber m_clientChannelNumber; 
  std::string m_strClientChannelName; 
  std::string
      m_strMimeType; 
  int m_iClientEncryptionSystem =
      -1; 
  std::string
      m_strClientEncryptionName; 
  int m_iClientOrder = 0; 
  int m_iClientProviderUid =
      PVR_PROVIDER_INVALID_UID; 
  int m_lastWatchedGroupId{
      -1}; 

  mutable CCriticalSection m_critSection;
};
} // namespace PVR