Recordings.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 "../../AddonBase.h"
#include "../../c-api/addon-instance/pvr.h"
 
//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// "C++" Definitions group 5 - PVR recordings
#ifdef __cplusplus
 
namespace kodi
{
namespace addon
{
 
//==============================================================================
class PVRRecording : public DynamicCStructHdl<PVRRecording, PVR_RECORDING>
{
  friend class CInstancePVRClient;
 
public:
  PVRRecording()
  {
    m_cStructure->iSeriesNumber = PVR_RECORDING_INVALID_SERIES_EPISODE;
    m_cStructure->iEpisodeNumber = PVR_RECORDING_INVALID_SERIES_EPISODE;
    m_cStructure->iEpisodePartNumber = PVR_RECORDING_INVALID_SERIES_EPISODE;
    m_cStructure->iDuration = PVR_RECORDING_VALUE_NOT_AVAILABLE;
    m_cStructure->iPriority = PVR_RECORDING_VALUE_NOT_AVAILABLE;
    m_cStructure->iLifetime = PVR_RECORDING_VALUE_NOT_AVAILABLE;
    m_cStructure->iGenreType = PVR_RECORDING_VALUE_NOT_AVAILABLE;
    m_cStructure->iGenreSubType = PVR_RECORDING_VALUE_NOT_AVAILABLE;
    m_cStructure->iPlayCount = PVR_RECORDING_VALUE_NOT_AVAILABLE;
    m_cStructure->iLastPlayedPosition = PVR_RECORDING_VALUE_NOT_AVAILABLE;
    m_cStructure->iChannelUid = PVR_RECORDING_VALUE_NOT_AVAILABLE;
    m_cStructure->channelType = PVR_RECORDING_CHANNEL_TYPE_UNKNOWN;
    m_cStructure->sizeInBytes = PVR_RECORDING_VALUE_NOT_AVAILABLE;
    m_cStructure->iClientProviderUid = PVR_PROVIDER_INVALID_UID;
  }
  PVRRecording(const PVRRecording& recording) : DynamicCStructHdl(recording) {}
 
 
  void SetRecordingId(const std::string& recordingId)
  {
    ReallocAndCopyString(&m_cStructure->strRecordingId, recordingId.c_str());
  }
 
  std::string GetRecordingId() const
  {
    return m_cStructure->strRecordingId ? m_cStructure->strRecordingId : "";
  }
 
  void SetTitle(const std::string& title)
  {
    ReallocAndCopyString(&m_cStructure->strTitle, title.c_str());
  }
 
  std::string GetTitle() const { return m_cStructure->strTitle ? m_cStructure->strTitle : ""; }
 
  void SetTitleExtraInfo(const std::string& titleExtraInfo)
  {
    ReallocAndCopyString(&m_cStructure->strTitleExtraInfo, titleExtraInfo.c_str());
  }
 
  std::string GetTitleExtraInfo() const
  {
    return m_cStructure->strTitleExtraInfo ? m_cStructure->strTitleExtraInfo : "";
  }
 
  void SetEpisodeName(const std::string& episodeName)
  {
    ReallocAndCopyString(&m_cStructure->strEpisodeName, episodeName.c_str());
  }
 
  std::string GetEpisodeName() const
  {
    return m_cStructure->strEpisodeName ? m_cStructure->strEpisodeName : "";
  }
 
  void SetSeriesNumber(int seriesNumber) { m_cStructure->iSeriesNumber = seriesNumber; }
 
  int GetSeriesNumber() const { return m_cStructure->iSeriesNumber; }
 
  void SetEpisodeNumber(int episodeNumber) { m_cStructure->iEpisodeNumber = episodeNumber; }
 
  int GetEpisodeNumber() const { return m_cStructure->iEpisodeNumber; }
 
  void SetEpisodePartNumber(int episodePartNumber)
  {
    m_cStructure->iEpisodePartNumber = episodePartNumber;
  }
 
  int GetEpisodePartNumber() const { return m_cStructure->iEpisodePartNumber; }
 
  void SetYear(int year) { m_cStructure->iYear = year; }
 
  int GetYear() const { return m_cStructure->iYear; }
 
  void SetDirectory(const std::string& directory)
  {
    ReallocAndCopyString(&m_cStructure->strDirectory, directory.c_str());
  }
 
  std::string GetDirectory() const
  {
    return m_cStructure->strDirectory ? m_cStructure->strDirectory : "";
  }
 
  void SetPlotOutline(const std::string& plotOutline)
  {
    ReallocAndCopyString(&m_cStructure->strPlotOutline, plotOutline.c_str());
  }
 
  std::string GetPlotOutline() const
  {
    return m_cStructure->strPlotOutline ? m_cStructure->strPlotOutline : "";
  }
 
  void SetPlot(const std::string& plot)
  {
    ReallocAndCopyString(&m_cStructure->strPlot, plot.c_str());
  }
 
  std::string GetPlot() const { return m_cStructure->strPlot ? m_cStructure->strPlot : ""; }
 
  void SetChannelName(const std::string& channelName)
  {
    ReallocAndCopyString(&m_cStructure->strChannelName, channelName.c_str());
  }
 
  std::string GetChannelName() const
  {
    return m_cStructure->strChannelName ? m_cStructure->strChannelName : "";
  }
 
  void SetIconPath(const std::string& iconPath)
  {
    ReallocAndCopyString(&m_cStructure->strIconPath, iconPath.c_str());
  }
 
  std::string GetIconPath() const
  {
    return m_cStructure->strIconPath ? m_cStructure->strIconPath : "";
  }
 
  void SetThumbnailPath(const std::string& thumbnailPath)
  {
    ReallocAndCopyString(&m_cStructure->strThumbnailPath, thumbnailPath.c_str());
  }
 
  std::string GetThumbnailPath() const
  {
    return m_cStructure->strThumbnailPath ? m_cStructure->strThumbnailPath : "";
  }
 
  void SetFanartPath(const std::string& fanartPath)
  {
    ReallocAndCopyString(&m_cStructure->strFanartPath, fanartPath.c_str());
  }
 
  std::string GetFanartPath() const
  {
    return m_cStructure->strFanartPath ? m_cStructure->strFanartPath : "";
  }
 
  void SetRecordingTime(time_t recordingTime) { m_cStructure->recordingTime = recordingTime; }
 
  time_t GetRecordingTime() const { return m_cStructure->recordingTime; }
 
  void SetDuration(int duration) { m_cStructure->iDuration = duration; }
 
  int GetDuration() const { return m_cStructure->iDuration; }
 
  void SetPriority(int priority) { m_cStructure->iPriority = priority; }
 
  int GetPriority() const { return m_cStructure->iPriority; }
 
  void SetLifetime(int lifetime) { m_cStructure->iLifetime = lifetime; }
 
  int GetLifetime() const { return m_cStructure->iLifetime; }
 
  void SetGenreType(int genreType) { m_cStructure->iGenreType = genreType; }
 
  int GetGenreType() const { return m_cStructure->iGenreType; }
 
  void SetGenreSubType(int genreSubType) { m_cStructure->iGenreSubType = genreSubType; }
 
  int GetGenreSubType() const { return m_cStructure->iGenreSubType; }
 
  void SetGenreDescription(const std::string& genreDescription)
  {
    ReallocAndCopyString(&m_cStructure->strGenreDescription, genreDescription.c_str());
  }
 
  std::string GetGenreDescription() const
  {
    return m_cStructure->strGenreDescription ? m_cStructure->strGenreDescription : "";
  }
 
  void SetPlayCount(int playCount) { m_cStructure->iPlayCount = playCount; }
 
  int GetPlayCount() const { return m_cStructure->iPlayCount; }
 
  void SetLastPlayedPosition(int lastPlayedPosition)
  {
    m_cStructure->iLastPlayedPosition = lastPlayedPosition;
  }
 
  int GetLastPlayedPosition() const { return m_cStructure->iLastPlayedPosition; }
 
  void SetIsDeleted(int isDeleted) { m_cStructure->bIsDeleted = isDeleted; }
 
  int GetIsDeleted() const { return m_cStructure->bIsDeleted; }
 
  void SetEPGEventId(unsigned int epgEventId) { m_cStructure->iEpgEventId = epgEventId; }
 
  unsigned int GetEPGEventId() const { return m_cStructure->iEpgEventId; }
 
  void SetChannelUid(int channelUid) { m_cStructure->iChannelUid = channelUid; }
 
  int GetChannelUid() const { return m_cStructure->iChannelUid; }
 
  void SetChannelType(PVR_RECORDING_CHANNEL_TYPE channelType)
  {
    m_cStructure->channelType = channelType;
  }
 
  PVR_RECORDING_CHANNEL_TYPE GetChannelType() const { return m_cStructure->channelType; }
 
  void SetFirstAired(const std::string& firstAired)
  {
    ReallocAndCopyString(&m_cStructure->strFirstAired, firstAired.c_str());
  }
 
  std::string GetFirstAired() const
  {
    return m_cStructure->strFirstAired ? m_cStructure->strFirstAired : "";
  }
 
  void SetFlags(unsigned int flags) { m_cStructure->iFlags = flags; }
 
  unsigned int GetFlags() const { return m_cStructure->iFlags; }
 
  void SetSizeInBytes(int64_t sizeInBytes) { m_cStructure->sizeInBytes = sizeInBytes; }
 
  int64_t GetSizeInBytes() const { return m_cStructure->sizeInBytes; }
 
  void SetClientProviderUid(int iClientProviderUid)
  {
    m_cStructure->iClientProviderUid = iClientProviderUid;
  }
 
  int GetClientProviderUid() const { return m_cStructure->iClientProviderUid; }
 
  void SetProviderName(const std::string& providerName)
  {
    ReallocAndCopyString(&m_cStructure->strProviderName, providerName.c_str());
  }
 
  std::string GetProviderName() const
  {
    return m_cStructure->strProviderName ? m_cStructure->strProviderName : "";
  }
 
  void SetParentalRating(unsigned int iParentalRating)
  {
    m_cStructure->iParentalRating = iParentalRating;
  }
 
  unsigned int GetParentalRating() const { return m_cStructure->iParentalRating; }
 
  void SetParentalRatingCode(const std::string& ratingCode)
  {
    ReallocAndCopyString(&m_cStructure->strParentalRatingCode, ratingCode.c_str());
  }
 
  std::string GetParentalRatingCode() const
  {
    return m_cStructure->strParentalRatingCode ? m_cStructure->strParentalRatingCode : "";
  }
 
  void SetParentalRatingIcon(const std::string& ratingIcon)
  {
    ReallocAndCopyString(&m_cStructure->strParentalRatingIcon, ratingIcon.c_str());
  }
 
  std::string GetParentalRatingIcon() const
  {
    return m_cStructure->strParentalRatingIcon ? m_cStructure->strParentalRatingIcon : "";
  }
 
  void SetParentalRatingSource(const std::string& ratingSource)
  {
    ReallocAndCopyString(&m_cStructure->strParentalRatingSource, ratingSource.c_str());
  }
 
  std::string GetParentalRatingSource() const
  {
    return m_cStructure->strParentalRatingSource ? m_cStructure->strParentalRatingSource : "";
  }
 
  static void AllocResources(const PVR_RECORDING* source, PVR_RECORDING* target)
  {
    target->strRecordingId = AllocAndCopyString(source->strRecordingId);
    target->strTitle = AllocAndCopyString(source->strTitle);
    target->strTitleExtraInfo = AllocAndCopyString(source->strTitleExtraInfo);
    target->strEpisodeName = AllocAndCopyString(source->strEpisodeName);
    target->strDirectory = AllocAndCopyString(source->strDirectory);
    target->strPlotOutline = AllocAndCopyString(source->strPlotOutline);
    target->strPlot = AllocAndCopyString(source->strPlot);
    target->strGenreDescription = AllocAndCopyString(source->strGenreDescription);
    target->strChannelName = AllocAndCopyString(source->strChannelName);
    target->strIconPath = AllocAndCopyString(source->strIconPath);
    target->strThumbnailPath = AllocAndCopyString(source->strThumbnailPath);
    target->strFanartPath = AllocAndCopyString(source->strFanartPath);
    target->strFirstAired = AllocAndCopyString(source->strFirstAired);
    target->strProviderName = AllocAndCopyString(source->strProviderName);
    target->strParentalRatingCode = AllocAndCopyString(source->strParentalRatingCode);
    target->strParentalRatingIcon = AllocAndCopyString(source->strParentalRatingIcon);
    target->strParentalRatingSource = AllocAndCopyString(source->strParentalRatingSource);
  }
 
  static void FreeResources(PVR_RECORDING* target)
  {
    FreeString(target->strRecordingId);
    FreeString(target->strTitle);
    FreeString(target->strTitleExtraInfo);
    FreeString(target->strEpisodeName);
    FreeString(target->strDirectory);
    FreeString(target->strPlotOutline);
    FreeString(target->strPlot);
    FreeString(target->strGenreDescription);
    FreeString(target->strChannelName);
    FreeString(target->strIconPath);
    FreeString(target->strThumbnailPath);
    FreeString(target->strFanartPath);
    FreeString(target->strFirstAired);
    FreeString(target->strProviderName);
    FreeString(target->strParentalRatingCode);
    FreeString(target->strParentalRatingIcon);
    FreeString(target->strParentalRatingSource);
  }
 
private:
  PVRRecording(const PVR_RECORDING* recording) : DynamicCStructHdl(recording) {}
  PVRRecording(PVR_RECORDING* recording) : DynamicCStructHdl(recording) {}
};
//------------------------------------------------------------------------------
 
//==============================================================================
class PVRRecordingsResultSet
{
public:
  PVRRecordingsResultSet() = delete;
  PVRRecordingsResultSet(const AddonInstance_PVR* instance, PVR_HANDLE handle)
    : m_instance(instance), m_handle(handle)
  {
  }
 
  void Add(const kodi::addon::PVRRecording& tag)
  {
    m_instance->toKodi->TransferRecordingEntry(m_instance->toKodi->kodiInstance, m_handle, tag);
  }
 
 
private:
  const AddonInstance_PVR* m_instance = nullptr;
  const PVR_HANDLE m_handle;
};
//------------------------------------------------------------------------------
 
} /* namespace addon */
} /* namespace kodi */
 
#endif /* __cplusplus */