PVRClient.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/binary-addons/AddonInstanceHandler.h"
#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/pvr.h"
#include "pvr/addons/PVRClientCapabilities.h"
#include "threads/Event.h"

#include <atomic>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>

struct DemuxPacket;

namespace PVR
{
class CPVRChannel;
class CPVRChannelGroup;
class CPVRChannelGroupMember;
class CPVRChannelGroups;
class CPVRProvider;
class CPVRProvidersContainer;
class CPVRClientMenuHook;
class CPVRClientMenuHooks;
class CPVREpg;
class CPVREpgInfoTag;
class CPVRRecording;
class CPVRRecordings;
class CPVRStreamProperties;
class CPVRTimerInfoTag;
class CPVRTimerType;
class CPVRTimersContainer;

#define PVR_INVALID_CLIENT_ID (-2)

class CPVRClient : public ADDON::IAddonInstanceHandler
{
public:
  CPVRClient(const ADDON::AddonInfoPtr& addonInfo, ADDON::AddonInstanceId instanceId, int clientId);
  ~CPVRClient() override;

  void OnPreInstall() override;
  void OnPreUnInstall() override;


  ADDON_STATUS Create();

  void Stop();

  void Continue();

  void Destroy();

  void ReCreate();

  bool ReadyToUse() const;

  PVR_CONNECTION_STATE GetConnectionState() const;

  void SetConnectionState(PVR_CONNECTION_STATE state);

  PVR_CONNECTION_STATE GetPreviousConnectionState() const;

  bool IgnoreClient() const;

  bool IsEnabled() const;

  int GetID() const;



  const CPVRClientCapabilities& GetClientCapabilities() const { return m_clientCapabilities; }

  PVR_ERROR GetStreamProperties(PVR_STREAM_PROPERTIES* pProperties);

  const std::string& GetBackendName() const;

  const std::string& GetBackendVersion() const;

  const std::string& GetBackendHostname() const;

  const std::string& GetConnectionString() const;

  const std::string GetFriendlyName() const;

  PVR_ERROR GetDriveSpace(uint64_t& iTotal, uint64_t& iUsed);

  PVR_ERROR StartChannelScan();

  PVR_ERROR OpenDialogChannelAdd(const std::shared_ptr<CPVRChannel>& channel);

  PVR_ERROR OpenDialogChannelSettings(const std::shared_ptr<CPVRChannel>& channel);

  PVR_ERROR DeleteChannel(const std::shared_ptr<CPVRChannel>& channel);

  PVR_ERROR RenameChannel(const std::shared_ptr<CPVRChannel>& channel);

  /*
   * @brief Check if an epg tag can be recorded
   * @param tag The epg tag
   * @param bIsRecordable Set to true if the tag can be recorded
   * @return PVR_ERROR_NO_ERROR if bIsRecordable has been set successfully.
   */
  PVR_ERROR IsRecordable(const std::shared_ptr<const CPVREpgInfoTag>& tag,
                         bool& bIsRecordable) const;

  /*
   * @brief Check if an epg tag can be played
   * @param tag The epg tag
   * @param bIsPlayable Set to true if the tag can be played
   * @return PVR_ERROR_NO_ERROR if bIsPlayable has been set successfully.
   */
  PVR_ERROR IsPlayable(const std::shared_ptr<const CPVREpgInfoTag>& tag, bool& bIsPlayable) const;

  PVR_ERROR GetEpgTagStreamProperties(const std::shared_ptr<CPVREpgInfoTag>& tag,
                                      CPVRStreamProperties& props);



  PVR_ERROR GetEPGForChannel(int iChannelUid, CPVREpg* epg, time_t start, time_t end);

  PVR_ERROR SetEPGMaxPastDays(int iPastDays);

  PVR_ERROR SetEPGMaxFutureDays(int iFutureDays);



  PVR_ERROR GetChannelGroupsAmount(int& iGroups);

  PVR_ERROR GetChannelGroups(CPVRChannelGroups* groups);

  PVR_ERROR GetChannelGroupMembers(
      CPVRChannelGroup* group, std::vector<std::shared_ptr<CPVRChannelGroupMember>>& groupMembers);



  PVR_ERROR GetChannelsAmount(int& iChannels);

  PVR_ERROR GetChannels(bool bRadio, std::vector<std::shared_ptr<CPVRChannel>>& channels);

  PVR_ERROR GetProvidersAmount(int& iProviders);

  PVR_ERROR GetProviders(CPVRProvidersContainer& providers);



  PVR_ERROR GetRecordingsAmount(bool deleted, int& iRecordings);

  PVR_ERROR GetRecordings(CPVRRecordings* results, bool deleted);

  PVR_ERROR DeleteRecording(const CPVRRecording& recording);

  PVR_ERROR UndeleteRecording(const CPVRRecording& recording);

  PVR_ERROR DeleteAllRecordingsFromTrash();

  PVR_ERROR RenameRecording(const CPVRRecording& recording);

  PVR_ERROR SetRecordingLifetime(const CPVRRecording& recording);

  PVR_ERROR SetRecordingPlayCount(const CPVRRecording& recording, int count);

  PVR_ERROR SetRecordingLastPlayedPosition(const CPVRRecording& recording, int lastplayedposition);

  PVR_ERROR GetRecordingLastPlayedPosition(const CPVRRecording& recording, int& iPosition);

  PVR_ERROR GetRecordingEdl(const CPVRRecording& recording, std::vector<PVR_EDL_ENTRY>& edls);

  PVR_ERROR GetRecordingSize(const CPVRRecording& recording, int64_t& sizeInBytes);

  PVR_ERROR GetEpgTagEdl(const std::shared_ptr<const CPVREpgInfoTag>& epgTag,
                         std::vector<PVR_EDL_ENTRY>& edls);



  PVR_ERROR GetTimersAmount(int& iTimers);

  PVR_ERROR GetTimers(CPVRTimersContainer* results);

  PVR_ERROR AddTimer(const CPVRTimerInfoTag& timer);

  PVR_ERROR DeleteTimer(const CPVRTimerInfoTag& timer, bool bForce = false);

  PVR_ERROR UpdateTimer(const CPVRTimerInfoTag& timer);

  PVR_ERROR UpdateTimerTypes();

  const std::vector<std::shared_ptr<CPVRTimerType>>& GetTimerTypes() const;



  PVR_ERROR OpenLiveStream(const std::shared_ptr<CPVRChannel>& channel);

  PVR_ERROR CloseLiveStream();

  PVR_ERROR ReadLiveStream(void* lpBuf, int64_t uiBufSize, int& iRead);

  PVR_ERROR SeekLiveStream(int64_t iFilePosition, int iWhence, int64_t& iPosition);

  PVR_ERROR GetLiveStreamLength(int64_t& iLength);

  PVR_ERROR PauseStream(bool bPaused);

  PVR_ERROR SignalQuality(int channelUid, PVR_SIGNAL_STATUS& qualityinfo);

  PVR_ERROR GetDescrambleInfo(int channelUid, PVR_DESCRAMBLE_INFO& descrambleinfo) const;

  PVR_ERROR GetChannelStreamProperties(const std::shared_ptr<CPVRChannel>& channel,
                                       CPVRStreamProperties& props);

  PVR_ERROR CanPauseStream(bool& bCanPause) const;

  PVR_ERROR CanSeekStream(bool& bCanSeek) const;

  PVR_ERROR SeekTime(double time, bool backwards, double* startpts);

  PVR_ERROR SetSpeed(int speed);

  PVR_ERROR FillBuffer(bool mode);



  PVR_ERROR OpenRecordedStream(const std::shared_ptr<CPVRRecording>& recording);

  PVR_ERROR CloseRecordedStream();

  PVR_ERROR ReadRecordedStream(void* lpBuf, int64_t uiBufSize, int& iRead);

  PVR_ERROR SeekRecordedStream(int64_t iFilePosition, int iWhence, int64_t& iPosition);

  PVR_ERROR GetRecordedStreamLength(int64_t& iLength);

  PVR_ERROR GetRecordingStreamProperties(const std::shared_ptr<CPVRRecording>& recording,
                                         CPVRStreamProperties& props);



  PVR_ERROR DemuxReset();

  PVR_ERROR DemuxAbort();

  PVR_ERROR DemuxFlush();

  PVR_ERROR DemuxRead(DemuxPacket*& packet);

  static const char* ToString(const PVR_ERROR error);

  PVR_ERROR IsRealTimeStream(bool& bRealTime) const;

  PVR_ERROR GetStreamTimes(PVR_STREAM_TIMES* times);

  std::shared_ptr<CPVRClientMenuHooks> GetMenuHooks();

  PVR_ERROR CallEpgTagMenuHook(const CPVRClientMenuHook& hook,
                               const std::shared_ptr<CPVREpgInfoTag>& tag);

  PVR_ERROR CallChannelMenuHook(const CPVRClientMenuHook& hook,
                                const std::shared_ptr<CPVRChannel>& channel);

  PVR_ERROR CallRecordingMenuHook(const CPVRClientMenuHook& hook,
                                  const std::shared_ptr<CPVRRecording>& recording,
                                  bool bDeleted);

  PVR_ERROR CallTimerMenuHook(const CPVRClientMenuHook& hook,
                              const std::shared_ptr<CPVRTimerInfoTag>& timer);

  PVR_ERROR CallSettingsMenuHook(const CPVRClientMenuHook& hook);

  PVR_ERROR OnSystemSleep();
  PVR_ERROR OnSystemWake();
  PVR_ERROR OnPowerSavingActivated();
  PVR_ERROR OnPowerSavingDeactivated();

  int GetPriority() const;

  void SetPriority(int iPriority);

  PVR_ERROR GetStreamReadChunkSize(int& iChunkSize);

  AddonInstance_PVR* GetInstanceInterface() { return m_ifc.pvr; }

private:
  void ResetProperties();

  bool GetAddonProperties();

  bool GetAddonNameStringProperties();

  static void WriteStreamProperties(const PVR_NAMED_VALUE* properties,
                                    unsigned int iPropertyCount,
                                    CPVRStreamProperties& props);

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

  void StopRunningInstance();

  typedef AddonInstance_PVR AddonInstance;
  PVR_ERROR DoAddonCall(const char* strFunctionName,
                        const std::function<PVR_ERROR(const AddonInstance*)>& function,
                        bool bIsImplemented = true,
                        bool bCheckReadyToUse = true) const;

  static void HandleAddonCallback(const char* strFunctionName,
                                  void* kodiInstance,
                                  const std::function<void(CPVRClient* client)>& function,
                                  bool bForceCall = false);


  static void cb_transfer_channel_group(void* kodiInstance,
                                        const PVR_HANDLE handle,
                                        const PVR_CHANNEL_GROUP* entry);

  static void cb_transfer_channel_group_member(void* kodiInstance,
                                               const PVR_HANDLE handle,
                                               const PVR_CHANNEL_GROUP_MEMBER* entry);

  static void cb_transfer_epg_entry(void* kodiInstance,
                                    const PVR_HANDLE handle,
                                    const EPG_TAG* entry);

  static void cb_transfer_channel_entry(void* kodiInstance,
                                        const PVR_HANDLE handle,
                                        const PVR_CHANNEL* entry);

  static void cb_transfer_provider_entry(void* kodiInstance,
                                         const PVR_HANDLE handle,
                                         const PVR_PROVIDER* entry);

  static void cb_transfer_timer_entry(void* kodiInstance,
                                      const PVR_HANDLE handle,
                                      const PVR_TIMER* entry);

  static void cb_transfer_recording_entry(void* kodiInstance,
                                          const PVR_HANDLE handle,
                                          const PVR_RECORDING* entry);

  static void cb_add_menu_hook(void* kodiInstance, const PVR_MENUHOOK* hook);

  static void cb_recording_notification(void* kodiInstance,
                                        const char* strName,
                                        const char* strFileName,
                                        bool bOnOff);

  static void cb_trigger_channel_update(void* kodiInstance);

  static void cb_trigger_provider_update(void* kodiInstance);

  static void cb_trigger_timer_update(void* kodiInstance);

  static void cb_trigger_recording_update(void* kodiInstance);

  static void cb_trigger_channel_groups_update(void* kodiInstance);

  static void cb_trigger_epg_update(void* kodiInstance, unsigned int iChannelUid);

  static void cb_free_demux_packet(void* kodiInstance, DEMUX_PACKET* pPacket);

  static DEMUX_PACKET* cb_allocate_demux_packet(void* kodiInstance, int iDataSize = 0);

  static void cb_connection_state_change(void* kodiInstance,
                                         const char* strConnectionString,
                                         PVR_CONNECTION_STATE newState,
                                         const char* strMessage);

  static void cb_epg_event_state_change(void* kodiInstance, EPG_TAG* tag, EPG_EVENT_STATE newState);

  static PVR_CODEC cb_get_codec_by_name(const void* kodiInstance, const char* strCodecName);

  const int m_iClientId; 
  std::atomic<bool>
      m_bReadyToUse; 
  std::atomic<bool> m_bBlockAddonCalls; 
  mutable std::atomic<int> m_iAddonCalls; 
  mutable CEvent m_allAddonCallsFinished; 
  PVR_CONNECTION_STATE m_connectionState; 
  PVR_CONNECTION_STATE m_prevConnectionState; 
  bool
      m_ignoreClient; 
  std::vector<std::shared_ptr<CPVRTimerType>>
      m_timertypes; 
  mutable std::optional<int> m_priority; 
  /* cached data */
  std::string m_strBackendName; 
  std::string m_strBackendVersion; 
  std::string m_strConnectionString; 
  std::string m_strBackendHostname; 
  CPVRClientCapabilities m_clientCapabilities; 
  std::shared_ptr<CPVRClientMenuHooks> m_menuhooks; 
  /* stored strings to make sure const char* members in AddonProperties_PVR stay valid */
  std::string m_strUserPath; 
  std::string m_strClientPath; 
  mutable CCriticalSection m_critSection;
};
} // namespace PVR