Timers.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"
#include "General.h"
 
//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// "C++" Definitions group 6 - PVR timers
#ifdef __cplusplus
 
namespace kodi
{
namespace addon
{
 
//==============================================================================
class PVRTimer : public DynamicCStructHdl<PVRTimer, PVR_TIMER>
{
  friend class CInstancePVRClient;
 
public:
  PVRTimer()
  {
    m_cStructure->state = PVR_TIMER_STATE_NEW;
    m_cStructure->iTimerType = PVR_TIMER_TYPE_NONE;
    m_cStructure->iClientChannelUid = PVR_TIMER_VALUE_NOT_AVAILABLE;
    m_cStructure->iPriority = PVR_TIMER_VALUE_NOT_AVAILABLE;
    m_cStructure->iLifetime = PVR_TIMER_VALUE_NOT_AVAILABLE;
    m_cStructure->iMaxRecordings = PVR_TIMER_VALUE_NOT_AVAILABLE;
    m_cStructure->iWeekdays = PVR_WEEKDAY_NONE;
    m_cStructure->iGenreType = PVR_TIMER_VALUE_NOT_AVAILABLE;
    m_cStructure->iGenreSubType = PVR_TIMER_VALUE_NOT_AVAILABLE;
  }
  PVRTimer(const PVRTimer& timer) : DynamicCStructHdl(timer) {}
 
 
  void SetClientIndex(unsigned int clientIndex) { m_cStructure->iClientIndex = clientIndex; }
 
  unsigned int GetClientIndex() const { return m_cStructure->iClientIndex; }
 
  void SetState(PVR_TIMER_STATE state) { m_cStructure->state = state; }
 
  PVR_TIMER_STATE GetState() const { return m_cStructure->state; }
 
  void SetTimerType(unsigned int timerType) { m_cStructure->iTimerType = timerType; }
 
  unsigned int GetTimerType() const { return m_cStructure->iTimerType; }
 
  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 SetParentClientIndex(unsigned int parentClientIndex)
  {
    m_cStructure->iParentClientIndex = parentClientIndex;
  }
 
  unsigned int GetParentClientIndex() const { return m_cStructure->iParentClientIndex; }
 
  void SetClientChannelUid(int clientChannelUid)
  {
    m_cStructure->iClientChannelUid = clientChannelUid;
  }
 
  int GetClientChannelUid() const { return m_cStructure->iClientChannelUid; }
 
  void SetStartTime(time_t startTime) { m_cStructure->startTime = startTime; }
 
  time_t GetStartTime() const { return m_cStructure->startTime; }
 
  void SetEndTime(time_t endTime) { m_cStructure->endTime = endTime; }
 
  time_t GetEndTime() const { return m_cStructure->endTime; }
 
  void SetStartAnyTime(bool startAnyTime) { m_cStructure->bStartAnyTime = startAnyTime; }
 
  bool GetStartAnyTime() const { return m_cStructure->bStartAnyTime; }
 
  void SetEndAnyTime(bool endAnyTime) { m_cStructure->bEndAnyTime = endAnyTime; }
 
  bool GetEndAnyTime() const { return m_cStructure->bEndAnyTime; }
 
  void SetEPGSearchString(const std::string& epgSearchString)
  {
    ReallocAndCopyString(&m_cStructure->strEpgSearchString, epgSearchString.c_str());
  }
 
  std::string GetEPGSearchString() const
  {
    return m_cStructure->strEpgSearchString ? m_cStructure->strEpgSearchString : "";
  }
 
  void SetFullTextEpgSearch(bool fullTextEpgSearch)
  {
    m_cStructure->bFullTextEpgSearch = fullTextEpgSearch;
  }
 
  bool GetFullTextEpgSearch() const { return m_cStructure->bFullTextEpgSearch; }
 
  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 SetSummary(const std::string& summary)
  {
    ReallocAndCopyString(&m_cStructure->strSummary, summary.c_str());
  }
 
  std::string GetSummary() const
  {
    return m_cStructure->strSummary ? m_cStructure->strSummary : "";
  }
 
  void SetPriority(int priority) { m_cStructure->iPriority = priority; }
 
  int GetPriority() const { return m_cStructure->iPriority; }
 
  void SetLifetime(int priority) { m_cStructure->iLifetime = priority; }
 
  int GetLifetime() const { return m_cStructure->iLifetime; }
 
  void SetMaxRecordings(int maxRecordings) { m_cStructure->iMaxRecordings = maxRecordings; }
 
  int GetMaxRecordings() const { return m_cStructure->iMaxRecordings; }
 
  void SetRecordingGroup(unsigned int recordingGroup)
  {
    m_cStructure->iRecordingGroup = recordingGroup;
  }
 
  unsigned int GetRecordingGroup() const { return m_cStructure->iRecordingGroup; }
 
  void SetFirstDay(time_t firstDay) { m_cStructure->firstDay = firstDay; }
 
  time_t GetFirstDay() const { return m_cStructure->firstDay; }
 
  void SetWeekdays(unsigned int weekdays) { m_cStructure->iWeekdays = weekdays; }
 
  unsigned int GetWeekdays() const { return m_cStructure->iWeekdays; }
 
  void SetPreventDuplicateEpisodes(unsigned int preventDuplicateEpisodes)
  {
    m_cStructure->iPreventDuplicateEpisodes = preventDuplicateEpisodes;
  }
 
  unsigned int GetPreventDuplicateEpisodes() const
  {
    return m_cStructure->iPreventDuplicateEpisodes;
  }
 
  void SetEPGUid(unsigned int epgUid) { m_cStructure->iEpgUid = epgUid; }
 
  unsigned int GetEPGUid() const { return m_cStructure->iEpgUid; }
 
  void SetMarginStart(unsigned int marginStart) { m_cStructure->iMarginStart = marginStart; }
 
  unsigned int GetMarginStart() const { return m_cStructure->iMarginStart; }
 
  void SetMarginEnd(unsigned int marginEnd) { m_cStructure->iMarginEnd = marginEnd; }
 
  unsigned int GetMarginEnd() const { return m_cStructure->iMarginEnd; }
 
  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 SetSeriesLink(const std::string& seriesLink)
  {
    ReallocAndCopyString(&m_cStructure->strSeriesLink, seriesLink.c_str());
  }
 
  std::string GetSeriesLink() const
  {
    return m_cStructure->strSeriesLink ? m_cStructure->strSeriesLink : "";
  }
 
  //----------------------------------------------------------------------------
 
  void SetCustomProperties(const std::vector<PVRSettingKeyValuePair>& properties)
  {
    PVRSettingKeyValuePair::ReallocAndCopyData(&m_cStructure->customProps,
                                               &m_cStructure->iCustomPropsSize, properties);
  }
 
  std::vector<PVRSettingKeyValuePair> GetCustomProperties() const
  {
    std::vector<PVRSettingKeyValuePair> ret;
    if (m_cStructure->iCustomPropsSize)
    {
      ret.reserve(m_cStructure->iCustomPropsSize);
      for (unsigned int i = 0; i < m_cStructure->iCustomPropsSize; ++i)
      {
        ret.emplace_back(m_cStructure->customProps[i].iKey, m_cStructure->customProps[i].eType,
                         m_cStructure->customProps[i].iValue,
                         m_cStructure->customProps[i].strValue);
      }
    }
    return ret;
  }
 
  static void AllocResources(const PVR_TIMER* source, PVR_TIMER* target)
  {
    target->strTitle = AllocAndCopyString(source->strTitle);
    target->strEpgSearchString = AllocAndCopyString(source->strEpgSearchString);
    target->strDirectory = AllocAndCopyString(source->strDirectory);
    target->strSummary = AllocAndCopyString(source->strSummary);
    target->strSeriesLink = AllocAndCopyString(source->strSeriesLink);
 
    target->customProps =
        PVRSettingKeyValuePair::AllocAndCopyData(source->customProps, source->iCustomPropsSize);
    target->iCustomPropsSize = source->iCustomPropsSize;
  }
 
  static void FreeResources(PVR_TIMER* target)
  {
    FreeString(target->strTitle);
    FreeString(target->strEpgSearchString);
    FreeString(target->strDirectory);
    FreeString(target->strSummary);
    FreeString(target->strSeriesLink);
 
    PVRSettingKeyValuePair::FreeResources(target->customProps, target->iCustomPropsSize);
    target->customProps = nullptr;
    target->iCustomPropsSize = 0;
  }
 
private:
  PVRTimer(const PVR_TIMER* timer) : DynamicCStructHdl(timer) {}
  PVRTimer(PVR_TIMER* timer) : DynamicCStructHdl(timer) {}
};
 
//------------------------------------------------------------------------------
 
//==============================================================================
class PVRTimersResultSet
{
public:
  PVRTimersResultSet() = delete;
  PVRTimersResultSet(const AddonInstance_PVR* instance, PVR_HANDLE handle)
    : m_instance(instance), m_handle(handle)
  {
  }
 
  void Add(const kodi::addon::PVRTimer& tag)
  {
    m_instance->toKodi->TransferTimerEntry(m_instance->toKodi->kodiInstance, m_handle, tag);
  }
 
 
private:
  const AddonInstance_PVR* m_instance = nullptr;
  const PVR_HANDLE m_handle;
};
//------------------------------------------------------------------------------
 
//==============================================================================
class PVRTimerType : public DynamicCStructHdl<PVRTimerType, PVR_TIMER_TYPE>
{
  friend class CInstancePVRClient;
 
public:
  PVRTimerType()
  {
    m_cStructure->iPrioritiesDefault = -1;
    m_cStructure->iLifetimesDefault = -1;
    m_cStructure->iPreventDuplicateEpisodesDefault = -1;
    m_cStructure->iRecordingGroupDefault = -1;
    m_cStructure->iMaxRecordingsDefault = -1;
  }
  PVRTimerType(const PVRTimerType& type) : DynamicCStructHdl(type) {}
 
 
  void SetId(unsigned int id) { m_cStructure->iId = id; }
 
  unsigned int GetId() const { return m_cStructure->iId; }
 
  void SetAttributes(uint64_t attributes) { m_cStructure->iAttributes = attributes; }
 
  uint64_t GetAttributes() const { return m_cStructure->iAttributes; }
 
  void SetDescription(const std::string& description)
  {
    ReallocAndCopyString(&m_cStructure->strDescription, description.c_str());
  }
 
  std::string GetDescription() const
  {
    return m_cStructure->strDescription ? m_cStructure->strDescription : "";
  }
 
  //----------------------------------------------------------------------------
 
  void SetPriorities(const std::vector<PVRTypeIntValue>& priorities, int prioritiesDefault = -1)
  {
    PVRTypeIntValue::ReallocAndCopyData(&m_cStructure->priorities, &m_cStructure->iPrioritiesSize,
                                        priorities);
    if (prioritiesDefault != -1)
      m_cStructure->iPrioritiesDefault = prioritiesDefault;
  }
 
  std::vector<PVRTypeIntValue> GetPriorities() const
  {
    std::vector<PVRTypeIntValue> ret;
    for (unsigned int i = 0; i < m_cStructure->iPrioritiesSize; ++i)
      ret.emplace_back(m_cStructure->priorities[i].iValue,
                       m_cStructure->priorities[i].strDescription);
    return ret;
  }
 
  void SetPrioritiesDefault(int prioritiesDefault)
  {
    m_cStructure->iPrioritiesDefault = prioritiesDefault;
  }
 
  int GetPrioritiesDefault() const { return m_cStructure->iPrioritiesDefault; }
 
  //----------------------------------------------------------------------------
 
  void SetLifetimes(const std::vector<PVRTypeIntValue>& lifetimes, int lifetimesDefault = -1)
  {
    PVRTypeIntValue::ReallocAndCopyData(&m_cStructure->lifetimes, &m_cStructure->iLifetimesSize,
                                        lifetimes);
    if (lifetimesDefault != -1)
      m_cStructure->iLifetimesDefault = lifetimesDefault;
  }
 
  std::vector<PVRTypeIntValue> GetLifetimes() const
  {
    std::vector<PVRTypeIntValue> ret;
    for (unsigned int i = 0; i < m_cStructure->iLifetimesSize; ++i)
      ret.emplace_back(m_cStructure->lifetimes[i].iValue,
                       m_cStructure->lifetimes[i].strDescription);
    return ret;
  }
 
  void SetLifetimesDefault(int lifetimesDefault)
  {
    m_cStructure->iLifetimesDefault = lifetimesDefault;
  }
 
  int GetLifetimesDefault() const { return m_cStructure->iLifetimesDefault; }
 
  //----------------------------------------------------------------------------
 
  void SetPreventDuplicateEpisodes(const std::vector<PVRTypeIntValue>& preventDuplicateEpisodes,
                                   int preventDuplicateEpisodesDefault = -1)
  {
    PVRTypeIntValue::ReallocAndCopyData(&m_cStructure->preventDuplicateEpisodes,
                                        &m_cStructure->iPreventDuplicateEpisodesSize,
                                        preventDuplicateEpisodes);
    if (preventDuplicateEpisodesDefault != -1)
      m_cStructure->iPreventDuplicateEpisodesDefault = preventDuplicateEpisodesDefault;
  }
 
  std::vector<PVRTypeIntValue> GetPreventDuplicateEpisodes() const
  {
    std::vector<PVRTypeIntValue> ret;
    for (unsigned int i = 0; i < m_cStructure->iPreventDuplicateEpisodesSize; ++i)
      ret.emplace_back(m_cStructure->preventDuplicateEpisodes[i].iValue,
                       m_cStructure->preventDuplicateEpisodes[i].strDescription);
    return ret;
  }
 
  void SetPreventDuplicateEpisodesDefault(int preventDuplicateEpisodesDefault)
  {
    m_cStructure->iPreventDuplicateEpisodesDefault = preventDuplicateEpisodesDefault;
  }
 
  int GetPreventDuplicateEpisodesDefault() const
  {
    return m_cStructure->iPreventDuplicateEpisodesDefault;
  }
 
  //----------------------------------------------------------------------------
 
  void SetRecordingGroups(const std::vector<PVRTypeIntValue>& recordingGroup,
                          int recordingGroupDefault = -1)
  {
    PVRTypeIntValue::ReallocAndCopyData(&m_cStructure->recordingGroup,
                                        &m_cStructure->iRecordingGroupSize, recordingGroup);
    if (recordingGroupDefault != -1)
      m_cStructure->iRecordingGroupDefault = recordingGroupDefault;
  }
 
  std::vector<PVRTypeIntValue> GetRecordingGroups() const
  {
    std::vector<PVRTypeIntValue> ret;
    for (unsigned int i = 0; i < m_cStructure->iRecordingGroupSize; ++i)
      ret.emplace_back(m_cStructure->recordingGroup[i].iValue,
                       m_cStructure->recordingGroup[i].strDescription);
    return ret;
  }
 
  void SetRecordingGroupDefault(int recordingGroupDefault)
  {
    m_cStructure->iRecordingGroupDefault = recordingGroupDefault;
  }
 
  int GetRecordingGroupDefault() const { return m_cStructure->iRecordingGroupDefault; }
 
  //----------------------------------------------------------------------------
 
  void SetMaxRecordings(const std::vector<PVRTypeIntValue>& maxRecordings,
                        int maxRecordingsDefault = -1)
  {
    PVRTypeIntValue::ReallocAndCopyData(&m_cStructure->maxRecordings,
                                        &m_cStructure->iMaxRecordingsSize, maxRecordings);
    if (maxRecordingsDefault != -1)
      m_cStructure->iMaxRecordingsDefault = maxRecordingsDefault;
  }
 
  std::vector<PVRTypeIntValue> GetMaxRecordings() const
  {
    std::vector<PVRTypeIntValue> ret;
    for (unsigned int i = 0; i < m_cStructure->iMaxRecordingsSize; ++i)
      ret.emplace_back(m_cStructure->maxRecordings[i].iValue,
                       m_cStructure->maxRecordings[i].strDescription);
    return ret;
  }
 
  void SetMaxRecordingsDefault(int maxRecordingsDefault)
  {
    m_cStructure->iMaxRecordingsDefault = maxRecordingsDefault;
  }
 
  int GetMaxRecordingsDefault() const { return m_cStructure->iMaxRecordingsDefault; }
 
  //----------------------------------------------------------------------------
 
  void SetCustomSettingDefinitions(const std::vector<PVRSettingDefinition>& defs)
  {
    PVRSettingDefinition::ReallocAndCopyData(&m_cStructure->customSettingDefs,
                                             &m_cStructure->iCustomSettingDefsSize, defs);
  }
 
  std::vector<PVRSettingDefinition> GetCustomSettingDefinitions() const
  {
    std::vector<PVRSettingDefinition> ret;
    if (m_cStructure->iCustomSettingDefsSize)
    {
      ret.reserve(m_cStructure->iCustomSettingDefsSize);
      for (unsigned int i = 0; i < m_cStructure->iCustomSettingDefsSize; ++i)
      {
        const PVR_SETTING_DEFINITION* def{m_cStructure->customSettingDefs[i]};
 
        PVRIntSettingDefinition intDef;
        if (def->intSettingDefinition)
        {
          const PVR_INT_SETTING_DEFINITION* intSettingDef{def->intSettingDefinition};
 
          std::vector<PVRTypeIntValue> intValues;
          if (intSettingDef->iValuesSize)
          {
            intValues.reserve(intSettingDef->iValuesSize);
            for (unsigned int j = 0; j < intSettingDef->iValuesSize; ++j)
            {
              intValues.emplace_back(intSettingDef->values[j].iValue,
                                     intSettingDef->values[j].strDescription);
            }
          }
          intDef = {intValues, intSettingDef->iDefaultValue, intSettingDef->iMinValue,
                    intSettingDef->iStep, intSettingDef->iMaxValue};
        }
 
        PVRStringSettingDefinition stringDef;
        if (def->stringSettingDefinition)
        {
          const PVR_STRING_SETTING_DEFINITION* stringSettingDef{def->stringSettingDefinition};
 
          std::vector<PVRTypeStringValue> stringValues;
          if (stringSettingDef->iValuesSize)
          {
            stringValues.reserve(stringSettingDef->iValuesSize);
            for (unsigned int j = 0; j < stringSettingDef->iValuesSize; ++j)
            {
              stringValues.emplace_back(stringSettingDef->values[j].strValue,
                                        stringSettingDef->values[j].strDescription);
            }
          }
          stringDef = {stringValues, stringSettingDef->strDefaultValue,
                       stringSettingDef->bAllowEmptyValue};
        }
 
        ret.emplace_back(def->iId, def->strName, def->eType, def->iReadonlyConditions, intDef,
                         stringDef);
      }
    }
    return ret;
  }
 
  static void AllocResources(const PVR_TIMER_TYPE* source, PVR_TIMER_TYPE* target)
  {
    target->strDescription = AllocAndCopyString(source->strDescription);
 
    if (target->iPrioritiesSize)
    {
      target->priorities =
          PVRTypeIntValue::AllocAndCopyData(source->priorities, source->iPrioritiesSize);
    }
 
    if (target->iLifetimesSize)
    {
      target->lifetimes =
          PVRTypeIntValue::AllocAndCopyData(source->lifetimes, source->iLifetimesSize);
    }
 
    if (target->iPreventDuplicateEpisodesSize)
    {
      target->preventDuplicateEpisodes = PVRTypeIntValue::AllocAndCopyData(
          source->preventDuplicateEpisodes, source->iPreventDuplicateEpisodesSize);
    }
 
    if (target->iRecordingGroupSize)
    {
      target->recordingGroup =
          PVRTypeIntValue::AllocAndCopyData(source->recordingGroup, source->iRecordingGroupSize);
    }
 
    if (target->iMaxRecordingsSize)
    {
      target->maxRecordings =
          PVRTypeIntValue::AllocAndCopyData(source->maxRecordings, source->iMaxRecordingsSize);
    }
 
    if (target->iCustomSettingDefsSize)
    {
      target->customSettingDefs = PVRSettingDefinition::AllocAndCopyData(
          source->customSettingDefs, source->iCustomSettingDefsSize);
    }
  }
 
  static void FreeResources(PVR_TIMER_TYPE* target)
  {
    FreeString(target->strDescription);
    target->strDescription = nullptr;
 
    PVRTypeIntValue::FreeResources(target->priorities, target->iPrioritiesSize);
    target->priorities = nullptr;
    target->iPrioritiesSize = 0;
 
    PVRTypeIntValue::FreeResources(target->lifetimes, target->iLifetimesSize);
    target->lifetimes = nullptr;
    target->iLifetimesSize = 0;
 
    PVRTypeIntValue::FreeResources(target->preventDuplicateEpisodes,
                                   target->iPreventDuplicateEpisodesSize);
    target->preventDuplicateEpisodes = nullptr;
    target->iPreventDuplicateEpisodesSize = 0;
 
    PVRTypeIntValue::FreeResources(target->recordingGroup, target->iRecordingGroupSize);
    target->recordingGroup = nullptr;
    target->iRecordingGroupSize = 0;
 
    PVRTypeIntValue::FreeResources(target->maxRecordings, target->iMaxRecordingsSize);
    target->maxRecordings = nullptr;
    target->iMaxRecordingsSize = 0;
 
    PVRSettingDefinition::FreeResources(target->customSettingDefs, target->iCustomSettingDefsSize);
    target->customSettingDefs = nullptr;
    target->iCustomSettingDefsSize = 0;
  }
 
private:
  PVRTimerType(const PVR_TIMER_TYPE* type) : DynamicCStructHdl(type) {}
  PVRTimerType(PVR_TIMER_TYPE* type) : DynamicCStructHdl(type) {}
};
//------------------------------------------------------------------------------
 
} /* namespace addon */
} /* namespace kodi */
 
#endif /* __cplusplus */