PVRRecording.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 "XBDateTime.h"
#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/pvr/pvr_providers.h"
#include "pvr/PVRCachedImage.h"
#include "threads/CriticalSection.h"
#include "threads/SystemClock.h"
#include "video/Bookmark.h"
#include "video/VideoInfoTag.h"

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

class CVideoDatabase;

struct PVR_EDL_ENTRY;
struct PVR_RECORDING;

namespace PVR
{
class CPVRChannel;
class CPVRClient;
class CPVRProvider;
class CPVRTimerInfoTag;

class CPVRRecordingUid final
{
public:
  int m_iClientId; 
  std::string m_strRecordingId; 
  CPVRRecordingUid(int iClientId, const std::string& strRecordingId);

  bool operator>(const CPVRRecordingUid& right) const;
  bool operator<(const CPVRRecordingUid& right) const;
  bool operator==(const CPVRRecordingUid& right) const;
  bool operator!=(const CPVRRecordingUid& right) const;
};

class CPVRRecording final : public CVideoInfoTag
{
public:
  static const std::string IMAGE_OWNER_PATTERN;

  CPVRRecording();
  CPVRRecording(const PVR_RECORDING& recording, unsigned int iClientId);

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

  void FillAddonData(PVR_RECORDING& recording) const;

  void Serialize(CVariant& value) const override;

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

  void Reset();

  bool Delete();

  bool Undelete();

  bool Rename(const std::string& strNewName);

  bool SetPlayCount(int count) override;

  bool IncrementPlayCount() override;

  bool SetLocalPlayCount(int count) { return CVideoInfoTag::SetPlayCount(count); }

  int GetLocalPlayCount() const { return CVideoInfoTag::GetPlayCount(); }

  bool SetResumePoint(const CBookmark& resumePoint) override;

  bool SetResumePoint(double timeInSeconds,
                      double totalTimeInSeconds,
                      const std::string& playerState = "") override;

  CBookmark GetResumePoint() const override;

  bool UpdateRecordingSize();

  CBookmark GetLocalResumePoint() const { return CVideoInfoTag::GetResumePoint(); }

  std::vector<PVR_EDL_ENTRY> GetEdl() const;

  void UpdateMetadata(CVideoDatabase& db, const CPVRClient& client);

  void Update(const CPVRRecording& tag, const CPVRClient& client);

  const CDateTime& RecordingTimeAsUTC() const { return m_recordingTime; }

  const CDateTime& RecordingTimeAsLocalTime() const;

  CDateTime EndTimeAsUTC() const;

  CDateTime EndTimeAsLocalTime() const;

  bool HasExpirationTime() const { return m_iLifetime > 0; }

  CDateTime ExpirationTimeAsLocalTime() const;

  bool WillBeExpiredWithNewLifetime(int iLifetime) const;

  static std::string GetTitleFromURL(const std::string& url);

  bool IsDeleted() const { return m_bIsDeleted; }

  bool IsRadio() const { return m_bRadio; }

  unsigned int BroadcastUid() const { return m_iEpgEventId; }

  std::shared_ptr<CPVRChannel> Channel() const;

  int ChannelUid() const;

  int ClientID() const;

  std::string ClientRecordingID() const { return m_strRecordingId; }

  unsigned int RecordingID() const { return m_iRecordingId; }

  void SetRecordingID(unsigned int recordingId) { m_iRecordingId = recordingId; }

  std::string Directory() const { return m_strDirectory; }

  int Priority() const { return m_iPriority; }

  int LifeTime() const { return m_iLifetime; }

  void SetLifeTime(int lifeTime) { m_iLifetime = lifeTime; }

  std::string ChannelName() const { return m_strChannelName; }

  const std::string& ClientIconPath() const { return m_iconPath.GetClientImage(); }

  const std::string& ClientThumbnailPath() const { return m_thumbnailPath.GetClientImage(); }

  const std::string& ClientFanartPath() const { return m_fanartPath.GetClientImage(); }

  const std::string& IconPath() const { return m_iconPath.GetLocalImage(); }

  const std::string& ThumbnailPath() const { return m_thumbnailPath.GetLocalImage(); }

  const std::string& FanartPath() const { return m_fanartPath.GetLocalImage(); }

  std::string EpisodeName() const { return m_strShowTitle; }

  bool IsInProgress() const;

  std::shared_ptr<CPVRTimerInfoTag> GetRecordingTimer() const;

  void SetGenre(int iGenreType, int iGenreSubType, const std::string& strGenre);

  int GenreType() const { return m_iGenreType; }

  int GenreSubType() const { return m_iGenreSubType; }

  const std::vector<std::string> Genre() const { return m_genre; }

  const std::string GetGenresLabel() const;

  CDateTime FirstAired() const;

  int GetYear() const override;

  void SetYear(int year) override;

  bool HasYear() const override;

  bool IsNew() const;

  bool IsPremiere() const;

  bool IsFinale() const;

  bool IsLive() const;

  unsigned int Flags() const { return m_iFlags; }

  int64_t GetSizeInBytes() const;

  void SetDirty(bool bDirty) { m_bDirty = bDirty; }

  bool IsDirty() const { return m_bDirty; }

  int ClientProviderUniqueId() const;

  std::string ProviderName() const;

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

  bool HasClientProvider() const;

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

private:
  CPVRRecording(const CPVRRecording& tag) = delete;
  CPVRRecording& operator=(const CPVRRecording& other) = delete;

  void UpdatePath();

  int m_iClientId; 
  std::string m_strRecordingId; 
  std::string m_strChannelName; 
  int m_iPriority; 
  int m_iLifetime; 
  std::string m_strDirectory; 
  unsigned int m_iRecordingId; 
  CPVRCachedImage m_iconPath; 
  CPVRCachedImage m_thumbnailPath; 
  CPVRCachedImage m_fanartPath; 
  CDateTime m_recordingTime; 
  bool m_bGotMetaData;
  bool m_bIsDeleted; 
  mutable bool m_bInProgress; 
  unsigned int m_iEpgEventId; 
  int m_iChannelUid; 
  bool m_bRadio; 
  int m_iGenreType = 0; 
  int m_iGenreSubType = 0; 
  mutable XbmcThreads::EndTime<> m_resumePointRefetchTimeout;
  unsigned int m_iFlags = 0; 
  mutable XbmcThreads::EndTime<> m_recordingSizeRefetchTimeout;
  int64_t m_sizeInBytes = 0; 
  bool m_bDirty = false;
  std::string m_strProviderName; 
  int m_iClientProviderUniqueId =
      PVR_PROVIDER_INVALID_UID; 
  mutable CCriticalSection m_critSection;
};
} // namespace PVR