Channels.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 2 - PVR channel
#ifdef __cplusplus
 
namespace kodi
{
namespace addon
{
 
//==============================================================================
class PVRChannel : public DynamicCStructHdl<PVRChannel, PVR_CHANNEL>
{
  friend class CInstancePVRClient;
 
public:
  PVRChannel() { m_cStructure->iClientProviderUid = PVR_PROVIDER_INVALID_UID; }
  PVRChannel(const PVRChannel& channel) : DynamicCStructHdl(channel) {}
 
 
  void SetUniqueId(unsigned int uniqueId) { m_cStructure->iUniqueId = uniqueId; }
 
  unsigned int GetUniqueId() const { return m_cStructure->iUniqueId; }
 
  void SetIsRadio(bool isRadio) { m_cStructure->bIsRadio = isRadio; }
 
  bool GetIsRadio() const { return m_cStructure->bIsRadio; }
 
  void SetChannelNumber(unsigned int channelNumber)
  {
    m_cStructure->iChannelNumber = channelNumber;
  }
 
  unsigned int GetChannelNumber() const { return m_cStructure->iChannelNumber; }
 
  void SetSubChannelNumber(unsigned int subChannelNumber)
  {
    m_cStructure->iSubChannelNumber = subChannelNumber;
  }
 
  unsigned int GetSubChannelNumber() const { return m_cStructure->iSubChannelNumber; }
 
  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 SetMimeType(const std::string& inputFormat)
  {
    ReallocAndCopyString(&m_cStructure->strMimeType, inputFormat.c_str());
  }
 
  std::string GetMimeType() const
  {
    return m_cStructure->strMimeType ? m_cStructure->strMimeType : "";
  }
 
  void SetEncryptionSystem(unsigned int encryptionSystem)
  {
    m_cStructure->iEncryptionSystem = encryptionSystem;
  }
 
  unsigned int GetEncryptionSystem() const { return m_cStructure->iEncryptionSystem; }
 
  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 SetIsHidden(bool isHidden) { m_cStructure->bIsHidden = isHidden; }
 
  bool GetIsHidden() const { return m_cStructure->bIsHidden; }
 
  void SetHasArchive(bool hasArchive) { m_cStructure->bHasArchive = hasArchive; }
 
  bool GetHasArchive() const { return m_cStructure->bHasArchive; }
 
  void SetOrder(bool order) { m_cStructure->iOrder = order; }
 
  bool GetOrder() const { return m_cStructure->iOrder; }
 
  void SetClientProviderUid(int iClientProviderUid)
  {
    m_cStructure->iClientProviderUid = iClientProviderUid;
  }
 
  int GetClientProviderUid() const { return m_cStructure->iClientProviderUid; }
 
  static void AllocResources(const PVR_CHANNEL* source, PVR_CHANNEL* target)
  {
    target->strChannelName = AllocAndCopyString(source->strChannelName);
    target->strMimeType = AllocAndCopyString(source->strMimeType);
    target->strIconPath = AllocAndCopyString(source->strIconPath);
  }
 
  static void FreeResources(PVR_CHANNEL* target)
  {
    FreeString(target->strChannelName);
    FreeString(target->strMimeType);
    FreeString(target->strIconPath);
  }
 
private:
  PVRChannel(const PVR_CHANNEL* channel) : DynamicCStructHdl(channel) {}
  PVRChannel(PVR_CHANNEL* channel) : DynamicCStructHdl(channel) {}
};
//------------------------------------------------------------------------------
 
//==============================================================================
class PVRChannelsResultSet
{
public:
  PVRChannelsResultSet() = delete;
  PVRChannelsResultSet(const AddonInstance_PVR* instance, PVR_HANDLE handle)
    : m_instance(instance), m_handle(handle)
  {
  }
 
  void Add(const kodi::addon::PVRChannel& tag)
  {
    m_instance->toKodi->TransferChannelEntry(m_instance->toKodi->kodiInstance, m_handle, tag);
  }
 
 
private:
  const AddonInstance_PVR* m_instance = nullptr;
  const PVR_HANDLE m_handle;
};
//------------------------------------------------------------------------------
 
//==============================================================================
class PVRSignalStatus : public DynamicCStructHdl<PVRSignalStatus, PVR_SIGNAL_STATUS>
{
  friend class CInstancePVRClient;
 
public:
  PVRSignalStatus() = default;
  PVRSignalStatus(const PVRSignalStatus& status) : DynamicCStructHdl(status) {}
 
 
  void SetAdapterName(const std::string& adapterName)
  {
    ReallocAndCopyString(&m_cStructure->strAdapterName, adapterName.c_str());
  }
 
  std::string GetAdapterName() const
  {
    return m_cStructure->strAdapterName ? m_cStructure->strAdapterName : "";
  }
 
  void SetAdapterStatus(const std::string& adapterStatus)
  {
    ReallocAndCopyString(&m_cStructure->strAdapterStatus, adapterStatus.c_str());
  }
 
  std::string GetAdapterStatus() const
  {
    return m_cStructure->strAdapterStatus ? m_cStructure->strAdapterStatus : "";
  }
 
  void SetServiceName(const std::string& serviceName)
  {
    ReallocAndCopyString(&m_cStructure->strServiceName, serviceName.c_str());
  }
 
  std::string GetServiceName() const
  {
    return m_cStructure->strServiceName ? m_cStructure->strServiceName : "";
  }
 
  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 SetMuxName(const std::string& muxName)
  {
    ReallocAndCopyString(&m_cStructure->strMuxName, muxName.c_str());
  }
 
  std::string GetMuxName() const
  {
    return m_cStructure->strMuxName ? m_cStructure->strMuxName : "";
  }
 
  void SetSNR(int snr) { m_cStructure->iSNR = snr; }
 
  int GetSNR() const { return m_cStructure->iSNR; }
 
  void SetSignal(int signal) { m_cStructure->iSignal = signal; }
 
  int GetSignal() const { return m_cStructure->iSignal; }
 
  void SetBER(long ber) { m_cStructure->iBER = ber; }
 
  long GetBER() const { return m_cStructure->iBER; }
 
  void SetUNC(long unc) { m_cStructure->iUNC = unc; }
 
  long GetUNC() const { return m_cStructure->iUNC; }
 
  static void AllocResources(const PVR_SIGNAL_STATUS* source, PVR_SIGNAL_STATUS* target)
  {
    target->strAdapterName = AllocAndCopyString(source->strAdapterName);
    target->strAdapterStatus = AllocAndCopyString(source->strAdapterStatus);
    target->strServiceName = AllocAndCopyString(source->strServiceName);
    target->strProviderName = AllocAndCopyString(source->strProviderName);
    target->strMuxName = AllocAndCopyString(source->strMuxName);
  }
 
  static void FreeResources(PVR_SIGNAL_STATUS* target)
  {
    FreeString(target->strAdapterName);
    FreeString(target->strAdapterStatus);
    FreeString(target->strServiceName);
    FreeString(target->strProviderName);
    FreeString(target->strMuxName);
  }
 
private:
  PVRSignalStatus(const PVR_SIGNAL_STATUS* status) : DynamicCStructHdl(status) {}
  PVRSignalStatus(PVR_SIGNAL_STATUS* status) : DynamicCStructHdl(status) {}
};
//------------------------------------------------------------------------------
 
//==============================================================================
class PVRDescrambleInfo : public DynamicCStructHdl<PVRDescrambleInfo, PVR_DESCRAMBLE_INFO>
{
  friend class CInstancePVRClient;
 
public:
  PVRDescrambleInfo()
  {
    m_cStructure->iPid = PVR_DESCRAMBLE_INFO_NOT_AVAILABLE;
    m_cStructure->iCaid = PVR_DESCRAMBLE_INFO_NOT_AVAILABLE;
    m_cStructure->iProvid = PVR_DESCRAMBLE_INFO_NOT_AVAILABLE;
    m_cStructure->iEcmTime = PVR_DESCRAMBLE_INFO_NOT_AVAILABLE;
    m_cStructure->iHops = PVR_DESCRAMBLE_INFO_NOT_AVAILABLE;
  }
  PVRDescrambleInfo(const PVRDescrambleInfo& info) : DynamicCStructHdl(info) {}
 
 
  void SetPID(int pid) { m_cStructure->iPid = pid; }
 
  int GetPID() const { return m_cStructure->iPid; }
 
  void SetCAID(int iCaid) { m_cStructure->iCaid = iCaid; }
 
  int GetCAID() const { return m_cStructure->iCaid; }
 
  void SetProviderID(int provid) { m_cStructure->iProvid = provid; }
 
  int GetProviderID() const { return m_cStructure->iProvid; }
 
  void SetECMTime(int ecmTime) { m_cStructure->iEcmTime = ecmTime; }
 
  int GetECMTime() const { return m_cStructure->iEcmTime; }
 
  void SetHops(int hops) { m_cStructure->iHops = hops; }
 
  int GetHops() const { return m_cStructure->iHops; }
 
  void SetCardSystem(const std::string& cardSystem)
  {
    ReallocAndCopyString(&m_cStructure->strCardSystem, cardSystem.c_str());
  }
 
  std::string GetCardSystem() const
  {
    return m_cStructure->strCardSystem ? m_cStructure->strCardSystem : "";
  }
 
  void SetReader(const std::string& reader)
  {
    ReallocAndCopyString(&m_cStructure->strReader, reader.c_str());
  }
 
  std::string GetReader() const { return m_cStructure->strReader ? m_cStructure->strReader : ""; }
 
  void SetFrom(const std::string& from)
  {
    ReallocAndCopyString(&m_cStructure->strFrom, from.c_str());
  }
 
  std::string GetFrom() const { return m_cStructure->strFrom ? m_cStructure->strFrom : ""; }
 
  void SetProtocol(const std::string& protocol)
  {
    ReallocAndCopyString(&m_cStructure->strProtocol, protocol.c_str());
  }
 
  std::string GetProtocol() const
  {
    return m_cStructure->strProtocol ? m_cStructure->strProtocol : "";
  }
 
  static void AllocResources(const PVR_DESCRAMBLE_INFO* source, PVR_DESCRAMBLE_INFO* target)
  {
    target->strCardSystem = AllocAndCopyString(source->strCardSystem);
    target->strReader = AllocAndCopyString(source->strReader);
    target->strFrom = AllocAndCopyString(source->strFrom);
    target->strProtocol = AllocAndCopyString(source->strProtocol);
  }
 
  static void FreeResources(PVR_DESCRAMBLE_INFO* target)
  {
    FreeString(target->strCardSystem);
    FreeString(target->strReader);
    FreeString(target->strFrom);
    FreeString(target->strProtocol);
  }
 
private:
  PVRDescrambleInfo(const PVR_DESCRAMBLE_INFO* info) : DynamicCStructHdl(info) {}
  PVRDescrambleInfo(PVR_DESCRAMBLE_INFO* info) : DynamicCStructHdl(info) {}
};
//------------------------------------------------------------------------------
 
} /* namespace addon */
} /* namespace kodi */
 
#endif /* __cplusplus */