xbmc/pvr/addons/PVRClient.cpp

   1 /*
   2  *  Copyright (C) 2012-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "PVRClient.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "addons/AddonManager.h"
  13 #include "addons/binary-addons/AddonDll.h"
  14 #include "cores/EdlEdit.h"
  15 #include "cores/VideoPlayer/DVDDemuxers/DVDDemuxUtils.h"
  16 #include "dialogs/GUIDialogKaiToast.h" //! @todo get rid of GUI in core
  17 #include "events/EventLog.h"
  18 #include "events/NotificationEvent.h"
  19 #include "filesystem/SpecialProtocol.h"
  20 #include "guilib/LocalizeStrings.h"
  21 #include "pvr/PVRConstants.h" // PVR_CLIENT_INVALID_UID
  22 #include "pvr/PVRDatabase.h"
  23 #include "pvr/PVRDescrambleInfo.h"
  24 #include "pvr/PVRManager.h"
  25 #include "pvr/PVRSignalStatus.h"
  26 #include "pvr/PVRStreamProperties.h"
  27 #include "pvr/addons/PVRClientMenuHooks.h"
  28 #include "pvr/addons/PVRClients.h"
  29 #include "pvr/channels/PVRChannel.h"
  30 #include "pvr/channels/PVRChannelGroup.h"
  31 #include "pvr/channels/PVRChannelGroupFactory.h"
  32 #include "pvr/channels/PVRChannelGroupMember.h"
  33 #include "pvr/channels/PVRChannelGroups.h"
  34 #include "pvr/channels/PVRChannelGroupsContainer.h"
  35 #include "pvr/epg/Epg.h"
  36 #include "pvr/epg/EpgContainer.h"
  37 #include "pvr/epg/EpgInfoTag.h"
  38 #include "pvr/providers/PVRProvider.h"
  39 #include "pvr/providers/PVRProviders.h"
  40 #include "pvr/recordings/PVRRecording.h"
  41 #include "pvr/recordings/PVRRecordings.h"
  42 #include "pvr/timers/PVRTimerInfoTag.h"
  43 #include "pvr/timers/PVRTimerType.h"
  44 #include "pvr/timers/PVRTimers.h"
  45 #include "settings/AdvancedSettings.h"
  46 #include "settings/SettingsComponent.h"
  47 #include "utils/StringUtils.h"
  48 #include "utils/log.h"
  49
  50 #include <chrono>
  51 #include <map>
  52 #include <memory>
  53 #include <mutex>
  54 #include <string>
  55 #include <utility>
  56
  57 extern "C"
  58 {
  59 #include <libavcodec/avcodec.h>
  60 }
  61
  62 using namespace ADDON;
  63 using namespace PVR;
  64
  65 namespace
  66 {
  67 class CAddonChannelGroup : public PVR_CHANNEL_GROUP
  68 {
  69 public:
  70   explicit CAddonChannelGroup(const CPVRChannelGroup& group) : m_groupName(group.ClientGroupName())
  71   {
  72     // zero-init base struct members
  73     PVR_CHANNEL_GROUP* base = static_cast<PVR_CHANNEL_GROUP*>(this);
  74     *base = {};
  75
  76     bIsRadio = group.IsRadio();
  77     strGroupName = m_groupName.c_str();
  78     iPosition = group.GetClientPosition();
  79   }
  80   virtual ~CAddonChannelGroup() = default;
  81
  82 private:
  83   const std::string m_groupName;
  84 };
  85
  86 class CAddonChannel : public PVR_CHANNEL
  87 {
  88 public:
  89   explicit CAddonChannel(const CPVRChannel& channel, const std::string& newChannelName = "")
  90     : m_channelName(newChannelName.empty() ? channel.ClientChannelName() : newChannelName),
  91       m_mimeType(channel.MimeType()),
  92       m_iconPath(channel.ClientIconPath())
  93   {
  94     // zero-init base struct members
  95     PVR_CHANNEL* base = static_cast<PVR_CHANNEL*>(this);
  96     *base = {};
  97
  98     iUniqueId = channel.UniqueID();
  99     iChannelNumber = channel.ClientChannelNumber().GetChannelNumber();
 100     iSubChannelNumber = channel.ClientChannelNumber().GetSubChannelNumber();
 101     strChannelName = m_channelName.c_str();
 102     strIconPath = m_iconPath.c_str();
 103     iEncryptionSystem = channel.EncryptionSystem();
 104     bIsRadio = channel.IsRadio();
 105     bIsHidden = channel.IsHidden();
 106     strMimeType = m_mimeType.c_str();
 107     iClientProviderUid = channel.ClientProviderUid();
 108     bHasArchive = channel.HasArchive();
 109   }
 110   virtual ~CAddonChannel() = default;
 111
 112 private:
 113   const std::string m_channelName;
 114   const std::string m_mimeType;
 115   const std::string m_iconPath;
 116 };
 117
 118 class CAddonRecording : public PVR_RECORDING
 119 {
 120 public:
 121   explicit CAddonRecording(const CPVRRecording& recording)
 122     : m_recordingId(recording.ClientRecordingID()),
 123       m_title(recording.m_strTitle),
 124       m_titleExtraInfo(recording.TitleExtraInfo()),
 125       m_episodeName(recording.m_strShowTitle),
 126       m_directory(recording.Directory()),
 127       m_plotOutline(recording.m_strPlotOutline),
 128       m_plot(recording.m_strPlot),
 129       m_genreDescription(recording.GetGenresLabel()),
 130       m_channelName(recording.ChannelName()),
 131       m_iconPath(recording.ClientIconPath()),
 132       m_thumbnailPath(recording.ClientThumbnailPath()),
 133       m_fanartPath(recording.ClientFanartPath()),
 134       m_firstAired(recording.FirstAired().IsValid() ? recording.FirstAired().GetAsW3CDate() : ""),
 135       m_providerName(recording.ProviderName()),
 136       m_parentalRatingCode(recording.GetParentalRatingCode()),
 137       m_parentalRatingIcon(recording.ClientParentalRatingIconPath()),
 138       m_parentalRatingSource(recording.GetParentalRatingSource())
 139   {
 140     // zero-init base struct members
 141     PVR_RECORDING* base = static_cast<PVR_RECORDING*>(this);
 142     *base = {};
 143
 144     time_t recTime;
 145     recording.RecordingTimeAsUTC().GetAsTime(recTime);
 146
 147     strRecordingId = m_recordingId.c_str();
 148     strTitle = m_title.c_str();
 149     strTitleExtraInfo = m_titleExtraInfo.c_str();
 150     strEpisodeName = m_episodeName.c_str();
 151     iSeriesNumber = recording.m_iSeason;
 152     iEpisodeNumber = recording.m_iEpisode;
 153     iEpisodePartNumber = recording.EpisodePart();
 154     iYear = recording.GetYear();
 155     strDirectory = m_directory.c_str();
 156     strPlotOutline = m_plotOutline.c_str();
 157     strPlot = m_plot.c_str();
 158     strGenreDescription = m_genreDescription.c_str();
 159     strChannelName = m_channelName.c_str();
 160     strIconPath = m_iconPath.c_str();
 161     strThumbnailPath = m_thumbnailPath.c_str();
 162     strFanartPath = m_fanartPath.c_str();
 163     recordingTime =
 164         recTime -
 165         CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_iPVRTimeCorrection;
 166     iDuration = recording.GetDuration();
 167     iPriority = recording.Priority();
 168     iLifetime = recording.LifeTime();
 169     iGenreType = recording.GenreType();
 170     iGenreSubType = recording.GenreSubType();
 171     iPlayCount = recording.GetLocalPlayCount();
 172     iLastPlayedPosition =
 173         static_cast<int>(std::lrint(recording.GetLocalResumePoint().timeInSeconds));
 174     bIsDeleted = recording.IsDeleted();
 175     iEpgEventId = recording.BroadcastUid();
 176     iChannelUid = recording.ChannelUid();
 177     channelType =
 178         recording.IsRadio() ? PVR_RECORDING_CHANNEL_TYPE_RADIO : PVR_RECORDING_CHANNEL_TYPE_TV;
 179     strFirstAired = m_firstAired.c_str();
 180     iFlags = recording.Flags();
 181     sizeInBytes = recording.GetSizeInBytes();
 182     strProviderName = m_providerName.c_str();
 183     iClientProviderUid = recording.ClientProviderUid();
 184     strParentalRatingCode = m_parentalRatingCode.c_str();
 185     strParentalRatingIcon = m_parentalRatingIcon.c_str();
 186     strParentalRatingSource = m_parentalRatingSource.c_str();
 187   }
 188   virtual ~CAddonRecording() = default;
 189
 190 private:
 191   const std::string m_recordingId;
 192   const std::string m_title;
 193   const std::string m_titleExtraInfo;
 194   const std::string m_episodeName;
 195   const std::string m_directory;
 196   const std::string m_plotOutline;
 197   const std::string m_plot;
 198   const std::string m_genreDescription;
 199   const std::string m_channelName;
 200   const std::string m_iconPath;
 201   const std::string m_thumbnailPath;
 202   const std::string m_fanartPath;
 203   const std::string m_firstAired;
 204   const std::string m_providerName;
 205   const std::string m_parentalRatingCode;
 206   const std::string m_parentalRatingIcon;
 207   const std::string m_parentalRatingSource;
 208 };
 209
 210 class CAddonTimer : public PVR_TIMER
 211 {
 212 public:
 213   explicit CAddonTimer(const CPVRTimerInfoTag& timer)
 214     : m_title(timer.Title()),
 215       m_epgSearchString(timer.EpgSearchString()),
 216       m_directory(timer.Directory()),
 217       m_summary(timer.Summary()),
 218       m_seriesLink(timer.SeriesLink())
 219   {
 220     // zero-init base struct members
 221     PVR_TIMER* base = static_cast<PVR_TIMER*>(this);
 222     *base = {};
 223
 224     time_t start;
 225     timer.StartAsUTC().GetAsTime(start);
 226     time_t end;
 227     timer.EndAsUTC().GetAsTime(end);
 228     time_t first;
 229     timer.FirstDayAsUTC().GetAsTime(first);
 230     const std::shared_ptr<const CPVREpgInfoTag> epgTag{timer.GetEpgInfoTag()};
 231     const int timeCorrection{
 232         CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_iPVRTimeCorrection};
 233
 234     iClientIndex = timer.ClientIndex();
 235     iParentClientIndex = timer.ParentClientIndex();
 236     state = timer.State();
 237     iTimerType = timer.GetTimerType()->GetTypeId();
 238     iClientChannelUid = timer.ClientChannelUID();
 239     strTitle = m_title.c_str();
 240     strEpgSearchString = m_epgSearchString.c_str();
 241     bFullTextEpgSearch = timer.IsFullTextEpgSearch();
 242     strDirectory = m_directory.c_str();
 243     iPriority = timer.Priority();
 244     iLifetime = timer.Lifetime();
 245     iMaxRecordings = timer.MaxRecordings();
 246     iPreventDuplicateEpisodes = timer.PreventDupEpisodesPolicy();
 247     iRecordingGroup = timer.RecordingGroup();
 248     iWeekdays = timer.WeekDays();
 249     startTime = start - timeCorrection;
 250     endTime = end - timeCorrection;
 251     bStartAnyTime = timer.IsStartAnyTime();
 252     bEndAnyTime = timer.IsEndAnyTime();
 253     firstDay = first - timeCorrection;
 254     iEpgUid = epgTag ? epgTag->UniqueBroadcastID() : PVR_TIMER_NO_EPG_UID;
 255     strSummary = m_summary.c_str();
 256     iMarginStart = timer.MarginStart();
 257     iMarginEnd = timer.MarginEnd();
 258     iGenreType = epgTag ? epgTag->GenreType() : 0;
 259     iGenreSubType = epgTag ? epgTag->GenreSubType() : 0;
 260     strSeriesLink = m_seriesLink.c_str();
 261
 262     const auto& props{timer.GetCustomProperties()};
 263     iCustomPropsSize = static_cast<unsigned int>(props.size());
 264     if (iCustomPropsSize)
 265     {
 266       m_customProps = std::make_unique<PVR_SETTING_KEY_VALUE_PAIR[]>(iCustomPropsSize);
 267       int idx{0};
 268       for (const auto& entry : props)
 269       {
 270         PVR_SETTING_KEY_VALUE_PAIR& prop{m_customProps[idx]};
 271         prop.iKey = entry.first;
 272         prop.eType = entry.second.type;
 273         prop.iValue = entry.second.value.asInteger32();
 274         m_customPropStringValues.emplace_back(entry.second.value.asString());
 275         prop.strValue = m_customPropStringValues.back().c_str();
 276         ++idx;
 277       }
 278       customProps = m_customProps.get();
 279     }
 280   }
 281   virtual ~CAddonTimer() = default;
 282
 283 private:
 284   const std::string m_title;
 285   const std::string m_epgSearchString;
 286   const std::string m_directory;
 287   const std::string m_summary;
 288   const std::string m_seriesLink;
 289   std::vector<std::string> m_customPropStringValues;
 290   std::unique_ptr<PVR_SETTING_KEY_VALUE_PAIR[]> m_customProps;
 291 };
 292
 293 class CAddonEpgTag : public EPG_TAG
 294 {
 295 public:
 296   explicit CAddonEpgTag(const CPVREpgInfoTag& tag)
 297     : m_title(tag.Title()),
 298       m_titleExtraInfo(tag.TitleExtraInfo()),
 299       m_plotOutline(tag.PlotOutline()),
 300       m_plot(tag.Plot()),
 301       m_originalTitle(tag.OriginalTitle()),
 302       m_cast(tag.DeTokenize(tag.Cast())),
 303       m_director(tag.DeTokenize(tag.Directors())),
 304       m_writer(tag.DeTokenize(tag.Writers())),
 305       m_IMDBNumber(tag.IMDBNumber()),
 306       m_episodeName(tag.EpisodeName()),
 307       m_iconPath(tag.ClientIconPath()),
 308       m_seriesLink(tag.SeriesLink()),
 309       m_genreDescription(tag.GenreDescription()),
 310       m_firstAired(GetFirstAired(tag)),
 311       m_parentalRatingCode(tag.ParentalRatingCode()),
 312       m_parentalRatingIcon(tag.ClientParentalRatingIconPath()),
 313       m_parentalRatingSource(tag.ParentalRatingSource())
 314   {
 315     // zero-init base struct members
 316     EPG_TAG* base = static_cast<EPG_TAG*>(this);
 317     *base = {};
 318
 319     time_t t;
 320     tag.StartAsUTC().GetAsTime(t);
 321     startTime = t;
 322     tag.EndAsUTC().GetAsTime(t);
 323     endTime = t;
 324
 325     iUniqueBroadcastId = tag.UniqueBroadcastID();
 326     iUniqueChannelId = tag.UniqueChannelID();
 327     iParentalRating = tag.ParentalRating();
 328     iSeriesNumber = tag.SeriesNumber();
 329     iEpisodeNumber = tag.EpisodeNumber();
 330     iEpisodePartNumber = tag.EpisodePart();
 331     iStarRating = tag.StarRating();
 332     iYear = tag.Year();
 333     iFlags = tag.Flags();
 334     iGenreType = tag.GenreType();
 335     iGenreSubType = tag.GenreSubType();
 336     strTitle = m_title.c_str();
 337     strTitleExtraInfo = m_titleExtraInfo.c_str();
 338     strPlotOutline = m_plotOutline.c_str();
 339     strPlot = m_plot.c_str();
 340     strOriginalTitle = m_originalTitle.c_str();
 341     strCast = m_cast.c_str();
 342     strDirector = m_director.c_str();
 343     strWriter = m_writer.c_str();
 344     strIMDBNumber = m_IMDBNumber.c_str();
 345     strEpisodeName = m_episodeName.c_str();
 346     strIconPath = m_iconPath.c_str();
 347     strSeriesLink = m_seriesLink.c_str();
 348     strGenreDescription = m_genreDescription.c_str();
 349     strFirstAired = m_firstAired.c_str();
 350     strParentalRatingCode = m_parentalRatingCode.c_str();
 351     strParentalRatingIcon = m_parentalRatingIcon.c_str();
 352     strParentalRatingSource = m_parentalRatingSource.c_str();
 353   }
 354
 355   virtual ~CAddonEpgTag() = default;
 356
 357 private:
 358   static std::string GetFirstAired(const CPVREpgInfoTag& tag)
 359   {
 360     const CDateTime firstAired{tag.FirstAired()};
 361     if (firstAired.IsValid())
 362       return firstAired.GetAsW3CDate();
 363     return {};
 364   }
 365
 366   const std::string m_title;
 367   const std::string m_titleExtraInfo;
 368   const std::string m_plotOutline;
 369   const std::string m_plot;
 370   const std::string m_originalTitle;
 371   const std::string m_cast;
 372   const std::string m_director;
 373   const std::string m_writer;
 374   const std::string m_IMDBNumber;
 375   const std::string m_episodeName;
 376   const std::string m_iconPath;
 377   const std::string m_seriesLink;
 378   const std::string m_genreDescription;
 379   const std::string m_firstAired;
 380   const std::string m_parentalRatingCode;
 381   const std::string m_parentalRatingIcon;
 382   const std::string m_parentalRatingSource;
 383 };
 384
 385 EDL::Edit ConvertAddonEdl(const PVR_EDL_ENTRY& entry)
 386 {
 387   EDL::Edit edit;
 388   edit.start = std::chrono::milliseconds(entry.start);
 389   edit.end = std::chrono::milliseconds(entry.end);
 390
 391   switch (entry.type)
 392   {
 393     case PVR_EDL_TYPE_CUT:
 394       edit.action = EDL::Action::CUT;
 395       break;
 396     case PVR_EDL_TYPE_MUTE:
 397       edit.action = EDL::Action::MUTE;
 398       break;
 399     case PVR_EDL_TYPE_SCENE:
 400       edit.action = EDL::Action::SCENE;
 401       break;
 402     case PVR_EDL_TYPE_COMBREAK:
 403       edit.action = EDL::Action::COMM_BREAK;
 404       break;
 405     default:
 406       CLog::LogF(LOGWARNING, "Ignoring entry of unknown EDL type: {}", entry.type);
 407       break;
 408   }
 409
 410   return edit;
 411 }
 412 } // unnamed namespace
 413
 414 namespace PVR
 415 {
 416
 417 #define DEFAULT_INFO_STRING_VALUE "unknown"
 418
 419 CPVRClient::CPVRClient(const ADDON::AddonInfoPtr& addonInfo,
 420                        ADDON::AddonInstanceId instanceId,
 421                        int clientId)
 422   : IAddonInstanceHandler(ADDON_INSTANCE_PVR, addonInfo, instanceId), m_iClientId(clientId)
 423 {
 424   // Create all interface parts independent to make API changes easier if
 425   // something is added
 426   m_ifc.pvr = new AddonInstance_PVR;
 427   m_ifc.pvr->props = new AddonProperties_PVR();
 428   m_ifc.pvr->toKodi = new AddonToKodiFuncTable_PVR();
 429   m_ifc.pvr->toAddon = new KodiToAddonFuncTable_PVR();
 430
 431   ResetProperties();
 432 }
 433
 434 CPVRClient::~CPVRClient()
 435 {
 436   Destroy();
 437
 438   if (m_ifc.pvr)
 439   {
 440     delete m_ifc.pvr->props;
 441     delete m_ifc.pvr->toKodi;
 442     delete m_ifc.pvr->toAddon;
 443   }
 444   delete m_ifc.pvr;
 445 }
 446
 447 void CPVRClient::StopRunningInstance()
 448 {
 449   // stop the pvr manager and stop and unload the running pvr addon. pvr manager will be restarted on demand.
 450   CServiceBroker::GetPVRManager().Stop();
 451   CServiceBroker::GetPVRManager().Clients()->StopClient(m_iClientId, false);
 452 }
 453
 454 void CPVRClient::OnPreInstall()
 455 {
 456   // note: this method is also called on update; thus stop and unload possibly running instance
 457   StopRunningInstance();
 458 }
 459
 460 void CPVRClient::OnPreUnInstall()
 461 {
 462   StopRunningInstance();
 463 }
 464
 465 void CPVRClient::ResetProperties()
 466 {
 467   std::unique_lock<CCriticalSection> lock(m_critSection);
 468
 469   /* initialise members */
 470   m_strUserPath = CSpecialProtocol::TranslatePath(Profile());
 471   m_strClientPath = CSpecialProtocol::TranslatePath(Path());
 472   m_bReadyToUse = false;
 473   m_bBlockAddonCalls = false;
 474   m_iAddonCalls = 0;
 475   m_allAddonCallsFinished.Set();
 476   m_connectionState = PVR_CONNECTION_STATE_UNKNOWN;
 477   m_prevConnectionState = PVR_CONNECTION_STATE_UNKNOWN;
 478   m_ignoreClient = false;
 479   m_priority.reset();
 480   m_strBackendVersion = DEFAULT_INFO_STRING_VALUE;
 481   m_strConnectionString = DEFAULT_INFO_STRING_VALUE;
 482   m_strBackendName = DEFAULT_INFO_STRING_VALUE;
 483   m_strBackendHostname.clear();
 484   m_menuhooks.reset();
 485   m_timertypes.clear();
 486   m_clientCapabilities.clear();
 487
 488   m_ifc.pvr->props->strUserPath = m_strUserPath.c_str();
 489   m_ifc.pvr->props->strClientPath = m_strClientPath.c_str();
 490   m_ifc.pvr->props->iEpgMaxPastDays =
 491       CServiceBroker::GetPVRManager().EpgContainer().GetPastDaysToDisplay();
 492   m_ifc.pvr->props->iEpgMaxFutureDays =
 493       CServiceBroker::GetPVRManager().EpgContainer().GetFutureDaysToDisplay();
 494
 495   m_ifc.pvr->toKodi->kodiInstance = this;
 496   m_ifc.pvr->toKodi->TransferEpgEntry = cb_transfer_epg_entry;
 497   m_ifc.pvr->toKodi->TransferChannelEntry = cb_transfer_channel_entry;
 498   m_ifc.pvr->toKodi->TransferProviderEntry = cb_transfer_provider_entry;
 499   m_ifc.pvr->toKodi->TransferTimerEntry = cb_transfer_timer_entry;
 500   m_ifc.pvr->toKodi->TransferRecordingEntry = cb_transfer_recording_entry;
 501   m_ifc.pvr->toKodi->AddMenuHook = cb_add_menu_hook;
 502   m_ifc.pvr->toKodi->RecordingNotification = cb_recording_notification;
 503   m_ifc.pvr->toKodi->TriggerChannelUpdate = cb_trigger_channel_update;
 504   m_ifc.pvr->toKodi->TriggerProvidersUpdate = cb_trigger_provider_update;
 505   m_ifc.pvr->toKodi->TriggerChannelGroupsUpdate = cb_trigger_channel_groups_update;
 506   m_ifc.pvr->toKodi->TriggerTimerUpdate = cb_trigger_timer_update;
 507   m_ifc.pvr->toKodi->TriggerRecordingUpdate = cb_trigger_recording_update;
 508   m_ifc.pvr->toKodi->TriggerEpgUpdate = cb_trigger_epg_update;
 509   m_ifc.pvr->toKodi->FreeDemuxPacket = cb_free_demux_packet;
 510   m_ifc.pvr->toKodi->AllocateDemuxPacket = cb_allocate_demux_packet;
 511   m_ifc.pvr->toKodi->TransferChannelGroup = cb_transfer_channel_group;
 512   m_ifc.pvr->toKodi->TransferChannelGroupMember = cb_transfer_channel_group_member;
 513   m_ifc.pvr->toKodi->ConnectionStateChange = cb_connection_state_change;
 514   m_ifc.pvr->toKodi->EpgEventStateChange = cb_epg_event_state_change;
 515   m_ifc.pvr->toKodi->GetCodecByName = cb_get_codec_by_name;
 516
 517   // Clear function addresses to have NULL if not set by addon
 518   memset(m_ifc.pvr->toAddon, 0, sizeof(KodiToAddonFuncTable_PVR));
 519 }
 520
 521 ADDON_STATUS CPVRClient::Create()
 522 {
 523   ResetProperties();
 524
 525   CLog::LogFC(LOGDEBUG, LOGPVR, "Creating PVR add-on instance [{},{},{}]", ID(), InstanceId(),
 526               m_iClientId);
 527
 528   const ADDON_STATUS status = CreateInstance();
 529
 530   if (status == ADDON_STATUS_OK)
 531   {
 532     m_bReadyToUse = GetAddonProperties();
 533
 534     CLog::LogFC(LOGDEBUG, LOGPVR,
 535                 "Created PVR add-on instance {}. readytouse={}, ignoreclient={}, "
 536                 "connectionstate={}",
 537                 GetID(), m_bReadyToUse, IgnoreClient(), GetConnectionState());
 538   }
 539   else
 540   {
 541     m_bReadyToUse = false;
 542
 543     CLog::LogF(LOGERROR, "Failed to create PVR add-on instance {}. status={}", GetID(), status);
 544   }
 545
 546   return status;
 547 }
 548
 549 void CPVRClient::Destroy()
 550 {
 551   if (!m_bReadyToUse)
 552     return;
 553
 554   m_bReadyToUse = false;
 555
 556   CLog::LogFC(LOGDEBUG, LOGPVR, "Destroying PVR add-on instance {}", GetID());
 557
 558   m_bBlockAddonCalls = true;
 559   m_allAddonCallsFinished.Wait();
 560
 561   DestroyInstance();
 562
 563   CLog::LogFC(LOGDEBUG, LOGPVR, "Destroyed PVR add-on instance {}", GetID());
 564
 565   if (m_menuhooks)
 566     m_menuhooks->Clear();
 567
 568   ResetProperties();
 569 }
 570
 571 void CPVRClient::Stop()
 572 {
 573   m_bBlockAddonCalls = true;
 574   m_priority.reset();
 575 }
 576
 577 void CPVRClient::Continue()
 578 {
 579   m_bBlockAddonCalls = false;
 580 }
 581
 582 void CPVRClient::ReCreate()
 583 {
 584   Destroy();
 585   Create();
 586 }
 587
 588 bool CPVRClient::ReadyToUse() const
 589 {
 590   return m_bReadyToUse;
 591 }
 592
 593 PVR_CONNECTION_STATE CPVRClient::GetConnectionState() const
 594 {
 595   std::unique_lock<CCriticalSection> lock(m_critSection);
 596   return m_connectionState;
 597 }
 598
 599 void CPVRClient::SetConnectionState(PVR_CONNECTION_STATE state)
 600 {
 601   if (state == PVR_CONNECTION_STATE_CONNECTED)
 602   {
 603     // update properties - some will only be available after add-on is connected to backend
 604     if (!GetAddonProperties())
 605       CLog::LogF(LOGERROR, "Error reading PVR client properties");
 606   }
 607   else
 608   {
 609     if (!GetAddonNameStringProperties())
 610       CLog::LogF(LOGERROR, "Cannot read PVR client name string properties");
 611   }
 612
 613   std::unique_lock<CCriticalSection> lock(m_critSection);
 614
 615   m_prevConnectionState = m_connectionState;
 616   m_connectionState = state;
 617
 618   if (m_connectionState == PVR_CONNECTION_STATE_CONNECTED)
 619     m_ignoreClient = false;
 620   else if (m_connectionState == PVR_CONNECTION_STATE_CONNECTING &&
 621            m_prevConnectionState == PVR_CONNECTION_STATE_UNKNOWN)
 622     m_ignoreClient = true; // ignore until connected
 623 }
 624
 625 PVR_CONNECTION_STATE CPVRClient::GetPreviousConnectionState() const
 626 {
 627   std::unique_lock<CCriticalSection> lock(m_critSection);
 628   return m_prevConnectionState;
 629 }
 630
 631 bool CPVRClient::IgnoreClient() const
 632 {
 633   std::unique_lock<CCriticalSection> lock(m_critSection);
 634   return m_ignoreClient;
 635 }
 636
 637 bool CPVRClient::IsEnabled() const
 638 {
 639   if (InstanceId() == ADDON_SINGLETON_INSTANCE_ID)
 640   {
 641     return !CServiceBroker::GetAddonMgr().IsAddonDisabled(ID());
 642   }
 643   else
 644   {
 645     bool instanceEnabled{false};
 646     Addon()->ReloadSettings(InstanceId());
 647     Addon()->GetSettingBool(ADDON_SETTING_INSTANCE_ENABLED_VALUE, instanceEnabled, InstanceId());
 648     return instanceEnabled;
 649   }
 650 }
 651
 652 int CPVRClient::GetID() const
 653 {
 654   return m_iClientId;
 655 }
 656
 657 bool CPVRClient::GetAddonProperties()
 658 {
 659   if (!GetAddonNameStringProperties())
 660     return false;
 661
 662   PVR_ADDON_CAPABILITIES addonCapabilities = {};
 663
 664   /* get the capabilities */
 665   PVR_ERROR retVal = DoAddonCall(
 666       __func__,
 667       [&addonCapabilities](const AddonInstance* addon)
 668       { return addon->toAddon->GetCapabilities(addon, &addonCapabilities); },
 669       true, false);
 670
 671   if (retVal == PVR_ERROR_NO_ERROR)
 672   {
 673     std::unique_lock<CCriticalSection> lock(m_critSection);
 674     m_clientCapabilities = addonCapabilities;
 675   }
 676
 677   /* free the resources of the capabilities instance */
 678   DoAddonCall(
 679       __func__,
 680       [&addonCapabilities](const AddonInstance* addon)
 681       { return addon->toAddon->FreeCapabilities(addon, &addonCapabilities); },
 682       true, false);
 683
 684   return (retVal == PVR_ERROR_NO_ERROR);
 685 }
 686
 687 bool CPVRClient::GetAddonNameStringProperties()
 688 {
 689   std::string backendName;
 690   std::string connectionString;
 691   std::string backendVersion;
 692   std::string backendHostname;
 693
 694   /* get the name of the backend */
 695   PVR_ERROR retVal = DoAddonCall(
 696       __func__,
 697       [&backendName](const AddonInstance* addon)
 698       {
 699         char* strBackendName{nullptr};
 700         const PVR_ERROR error{addon->toAddon->GetBackendName(addon, &strBackendName)};
 701         if (error == PVR_ERROR_NO_ERROR && strBackendName != nullptr)
 702           backendName = strBackendName;
 703         addon->toAddon->FreeString(addon, strBackendName);
 704         return error;
 705       },
 706       true, false);
 707
 708   if (retVal != PVR_ERROR_NO_ERROR)
 709     return false;
 710
 711   /* get the connection string */
 712   retVal = DoAddonCall(
 713       __func__,
 714       [&connectionString](const AddonInstance* addon)
 715       {
 716         char* strConnectionString{nullptr};
 717         const PVR_ERROR error{addon->toAddon->GetConnectionString(addon, &strConnectionString)};
 718         if (error == PVR_ERROR_NO_ERROR && strConnectionString != nullptr)
 719           connectionString = strConnectionString;
 720         addon->toAddon->FreeString(addon, strConnectionString);
 721         return error;
 722       },
 723       true, false);
 724
 725   if (retVal != PVR_ERROR_NO_ERROR && retVal != PVR_ERROR_NOT_IMPLEMENTED)
 726     return false;
 727
 728   /* backend version number */
 729   retVal = DoAddonCall(
 730       __func__,
 731       [&backendVersion](const AddonInstance* addon)
 732       {
 733         char* strBackendVersion{nullptr};
 734         const PVR_ERROR error{addon->toAddon->GetBackendVersion(addon, &strBackendVersion)};
 735         if (error == PVR_ERROR_NO_ERROR && strBackendVersion != nullptr)
 736           backendVersion = strBackendVersion;
 737         addon->toAddon->FreeString(addon, strBackendVersion);
 738         return error;
 739       },
 740       true, false);
 741
 742   if (retVal != PVR_ERROR_NO_ERROR)
 743     return false;
 744
 745   /* backend hostname */
 746   retVal = DoAddonCall(
 747       __func__,
 748       [&backendHostname](const AddonInstance* addon)
 749       {
 750         char* strBackendHostname{nullptr};
 751         const PVR_ERROR error{addon->toAddon->GetBackendHostname(addon, &strBackendHostname)};
 752         if (error == PVR_ERROR_NO_ERROR && strBackendHostname != nullptr)
 753           backendHostname = strBackendHostname;
 754         addon->toAddon->FreeString(addon, strBackendHostname);
 755         return error;
 756       },
 757       true, false);
 758
 759   if (retVal != PVR_ERROR_NO_ERROR && retVal != PVR_ERROR_NOT_IMPLEMENTED)
 760     return false;
 761
 762   /* update the members */
 763   std::unique_lock<CCriticalSection> lock(m_critSection);
 764   m_strBackendName = backendName;
 765   m_strConnectionString = connectionString;
 766   m_strBackendVersion = backendVersion;
 767   m_strBackendHostname = backendHostname;
 768
 769   return true;
 770 }
 771
 772 const std::string& CPVRClient::GetBackendName() const
 773 {
 774   return m_strBackendName;
 775 }
 776
 777 const std::string& CPVRClient::GetBackendVersion() const
 778 {
 779   return m_strBackendVersion;
 780 }
 781
 782 const std::string& CPVRClient::GetBackendHostname() const
 783 {
 784   return m_strBackendHostname;
 785 }
 786
 787 const std::string& CPVRClient::GetConnectionString() const
 788 {
 789   return m_strConnectionString;
 790 }
 791
 792 std::string CPVRClient::GetClientName() const
 793 {
 794   return Name();
 795 }
 796
 797 std::string CPVRClient::GetInstanceName() const
 798 {
 799   std::string instanceName;
 800   if (Addon()->SupportsInstanceSettings())
 801     Addon()->GetSettingString(ADDON_SETTING_INSTANCE_NAME_VALUE, instanceName, InstanceId());
 802
 803   return instanceName;
 804 }
 805
 806 std::string CPVRClient::GetFullClientName() const
 807 {
 808   if (Addon()->SupportsInstanceSettings())
 809   {
 810     std::string instanceName;
 811     Addon()->GetSettingString(ADDON_SETTING_INSTANCE_NAME_VALUE, instanceName, InstanceId());
 812     if (!instanceName.empty())
 813       return StringUtils::Format("{} ({})", Name(), instanceName);
 814   }
 815   return Name();
 816 }
 817
 818 PVR_ERROR CPVRClient::GetDriveSpace(uint64_t& iTotal, uint64_t& iUsed) const
 819 {
 820   /* default to 0 in case of error */
 821   iTotal = 0;
 822   iUsed = 0;
 823
 824   return DoAddonCall(__func__,
 825                      [&iTotal, &iUsed](const AddonInstance* addon)
 826                      {
 827                        uint64_t iTotalSpace = 0;
 828                        uint64_t iUsedSpace = 0;
 829                        PVR_ERROR error =
 830                            addon->toAddon->GetDriveSpace(addon, &iTotalSpace, &iUsedSpace);
 831                        if (error == PVR_ERROR_NO_ERROR)
 832                        {
 833                          iTotal = iTotalSpace;
 834                          iUsed = iUsedSpace;
 835                        }
 836                        return error;
 837                      });
 838 }
 839
 840 PVR_ERROR CPVRClient::StartChannelScan()
 841 {
 842   return DoAddonCall(
 843       __func__,
 844       [](const AddonInstance* addon) { return addon->toAddon->OpenDialogChannelScan(addon); },
 845       m_clientCapabilities.SupportsChannelScan());
 846 }
 847
 848 PVR_ERROR CPVRClient::OpenDialogChannelAdd(const std::shared_ptr<const CPVRChannel>& channel)
 849 {
 850   return DoAddonCall(
 851       __func__,
 852       [channel](const AddonInstance* addon)
 853       {
 854         const CAddonChannel addonChannel{*channel};
 855         return addon->toAddon->OpenDialogChannelAdd(addon, &addonChannel);
 856       },
 857       m_clientCapabilities.SupportsChannelSettings());
 858 }
 859
 860 PVR_ERROR CPVRClient::OpenDialogChannelSettings(const std::shared_ptr<const CPVRChannel>& channel)
 861 {
 862   return DoAddonCall(
 863       __func__,
 864       [channel](const AddonInstance* addon)
 865       {
 866         const CAddonChannel addonChannel{*channel};
 867         return addon->toAddon->OpenDialogChannelSettings(addon, &addonChannel);
 868       },
 869       m_clientCapabilities.SupportsChannelSettings());
 870 }
 871
 872 PVR_ERROR CPVRClient::DeleteChannel(const std::shared_ptr<const CPVRChannel>& channel)
 873 {
 874   return DoAddonCall(
 875       __func__,
 876       [channel](const AddonInstance* addon)
 877       {
 878         const CAddonChannel addonChannel{*channel};
 879         return addon->toAddon->DeleteChannel(addon, &addonChannel);
 880       },
 881       m_clientCapabilities.SupportsChannelSettings());
 882 }
 883
 884 PVR_ERROR CPVRClient::RenameChannel(const std::shared_ptr<const CPVRChannel>& channel)
 885 {
 886   return DoAddonCall(
 887       __func__,
 888       [channel](const AddonInstance* addon)
 889       {
 890         const CAddonChannel addonChannel{*channel, channel->ChannelName()};
 891         return addon->toAddon->RenameChannel(addon, &addonChannel);
 892       },
 893       m_clientCapabilities.SupportsChannelSettings());
 894 }
 895
 896 PVR_ERROR CPVRClient::GetEPGForChannel(int iChannelUid,
 897                                        CPVREpg* epg,
 898                                        time_t start,
 899                                        time_t end) const
 900 {
 901   return DoAddonCall(
 902       __func__,
 903       [this, iChannelUid, epg, start, end](const AddonInstance* addon)
 904       {
 905         PVR_HANDLE_STRUCT handle = {};
 906         handle.callerAddress = this;
 907         handle.dataAddress = epg;
 908
 909         int iPVRTimeCorrection =
 910             CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_iPVRTimeCorrection;
 911
 912         return addon->toAddon->GetEPGForChannel(addon, &handle, iChannelUid,
 913                                                 start ? start - iPVRTimeCorrection : 0,
 914                                                 end ? end - iPVRTimeCorrection : 0);
 915       },
 916       m_clientCapabilities.SupportsEPG());
 917 }
 918
 919 PVR_ERROR CPVRClient::SetEPGMaxPastDays(int iPastDays)
 920 {
 921   return DoAddonCall(
 922       __func__,
 923       [iPastDays](const AddonInstance* addon)
 924       { return addon->toAddon->SetEPGMaxPastDays(addon, iPastDays); },
 925       m_clientCapabilities.SupportsEPG());
 926 }
 927
 928 PVR_ERROR CPVRClient::SetEPGMaxFutureDays(int iFutureDays)
 929 {
 930   return DoAddonCall(
 931       __func__,
 932       [iFutureDays](const AddonInstance* addon)
 933       { return addon->toAddon->SetEPGMaxFutureDays(addon, iFutureDays); },
 934       m_clientCapabilities.SupportsEPG());
 935 }
 936
 937 PVR_ERROR CPVRClient::IsRecordable(const std::shared_ptr<const CPVREpgInfoTag>& tag,
 938                                    bool& bIsRecordable) const
 939 {
 940   return DoAddonCall(
 941       __func__,
 942       [tag, &bIsRecordable](const AddonInstance* addon)
 943       {
 944         CAddonEpgTag addonTag(*tag);
 945         return addon->toAddon->IsEPGTagRecordable(addon, &addonTag, &bIsRecordable);
 946       },
 947       m_clientCapabilities.SupportsRecordings() && m_clientCapabilities.SupportsEPG());
 948 }
 949
 950 PVR_ERROR CPVRClient::IsPlayable(const std::shared_ptr<const CPVREpgInfoTag>& tag,
 951                                  bool& bIsPlayable) const
 952 {
 953   return DoAddonCall(
 954       __func__,
 955       [tag, &bIsPlayable](const AddonInstance* addon)
 956       {
 957         CAddonEpgTag addonTag(*tag);
 958         return addon->toAddon->IsEPGTagPlayable(addon, &addonTag, &bIsPlayable);
 959       },
 960       m_clientCapabilities.SupportsEPG());
 961 }
 962
 963 void CPVRClient::WriteStreamProperties(PVR_NAMED_VALUE** properties,
 964                                        unsigned int iPropertyCount,
 965                                        CPVRStreamProperties& props)
 966 {
 967   for (unsigned int i = 0; i < iPropertyCount; ++i)
 968   {
 969     const PVR_NAMED_VALUE* prop{properties[i]};
 970     props.emplace_back(std::make_pair(prop->strName, prop->strValue));
 971   }
 972 }
 973
 974 PVR_ERROR CPVRClient::GetEpgTagStreamProperties(const std::shared_ptr<const CPVREpgInfoTag>& tag,
 975                                                 CPVRStreamProperties& props) const
 976 {
 977   return DoAddonCall(__func__,
 978                      [&tag, &props](const AddonInstance* addon)
 979                      {
 980                        CAddonEpgTag addonTag(*tag);
 981
 982                        PVR_NAMED_VALUE** property_array{nullptr};
 983                        unsigned int size{0};
 984                        const PVR_ERROR error{addon->toAddon->GetEPGTagStreamProperties(
 985                            addon, &addonTag, &property_array, &size)};
 986                        if (error == PVR_ERROR_NO_ERROR)
 987                          WriteStreamProperties(property_array, size, props);
 988
 989                        addon->toAddon->FreeProperties(addon, property_array, size);
 990                        return error;
 991                      });
 992 }
 993
 994 PVR_ERROR CPVRClient::GetEpgTagEdl(const std::shared_ptr<const CPVREpgInfoTag>& epgTag,
 995                                    std::vector<EDL::Edit>& edls) const
 996 {
 997   edls.clear();
 998   return DoAddonCall(
 999       __func__,
1000       [&epgTag, &edls](const AddonInstance* addon)
1001       {
1002         CAddonEpgTag addonTag(*epgTag);
1003
1004         PVR_EDL_ENTRY** edl_array{nullptr};
1005         unsigned int size{0};
1006         const PVR_ERROR error{addon->toAddon->GetEPGTagEdl(addon, &addonTag, &edl_array, &size)};
1007         if (error == PVR_ERROR_NO_ERROR)
1008         {
1009           edls.reserve(size);
1010           for (unsigned int i = 0; i < size; ++i)
1011             edls.emplace_back(ConvertAddonEdl(*edl_array[i]));
1012         }
1013         addon->toAddon->FreeEdlEntries(addon, edl_array, size);
1014         return error;
1015       },
1016       m_clientCapabilities.SupportsEpgTagEdl());
1017 }
1018
1019 PVR_ERROR CPVRClient::GetChannelGroupsAmount(int& iGroups) const
1020 {
1021   iGroups = -1;
1022   return DoAddonCall(
1023       __func__,
1024       [&iGroups](const AddonInstance* addon)
1025       { return addon->toAddon->GetChannelGroupsAmount(addon, &iGroups); },
1026       m_clientCapabilities.SupportsChannelGroups());
1027 }
1028
1029 PVR_ERROR CPVRClient::GetChannelGroups(CPVRChannelGroups* groups) const
1030 {
1031   const bool radio{groups->IsRadio()};
1032   return DoAddonCall(
1033       __func__,
1034       [this, groups](const AddonInstance* addon)
1035       {
1036         PVR_HANDLE_STRUCT handle = {};
1037         handle.callerAddress = this;
1038         handle.dataAddress = groups;
1039         return addon->toAddon->GetChannelGroups(addon, &handle, groups->IsRadio());
1040       },
1041       m_clientCapabilities.SupportsChannelGroups() &&
1042           ((radio && m_clientCapabilities.SupportsRadio()) ||
1043            (!radio && m_clientCapabilities.SupportsTV())));
1044 }
1045
1046 PVR_ERROR CPVRClient::GetChannelGroupMembers(
1047     CPVRChannelGroup* group,
1048     std::vector<std::shared_ptr<CPVRChannelGroupMember>>& groupMembers) const
1049 {
1050   const bool radio{group->IsRadio()};
1051   return DoAddonCall(
1052       __func__,
1053       [this, group, &groupMembers](const AddonInstance* addon)
1054       {
1055         PVR_HANDLE_STRUCT handle = {};
1056         handle.callerAddress = this;
1057         handle.dataAddress = &groupMembers;
1058
1059         const CAddonChannelGroup addonGroup{*group};
1060         return addon->toAddon->GetChannelGroupMembers(addon, &handle, &addonGroup);
1061       },
1062       m_clientCapabilities.SupportsChannelGroups() &&
1063           ((radio && m_clientCapabilities.SupportsRadio()) ||
1064            (!radio && m_clientCapabilities.SupportsTV())));
1065 }
1066
1067 PVR_ERROR CPVRClient::GetProvidersAmount(int& iProviders) const
1068 {
1069   iProviders = -1;
1070   return DoAddonCall(__func__, [&iProviders](const AddonInstance* addon)
1071                      { return addon->toAddon->GetProvidersAmount(addon, &iProviders); });
1072 }
1073
1074 PVR_ERROR CPVRClient::GetProviders(CPVRProvidersContainer& providers) const
1075 {
1076   return DoAddonCall(
1077       __func__,
1078       [this, &providers](const AddonInstance* addon)
1079       {
1080         PVR_HANDLE_STRUCT handle = {};
1081         handle.callerAddress = this;
1082         handle.dataAddress = &providers;
1083         return addon->toAddon->GetProviders(addon, &handle);
1084       },
1085       m_clientCapabilities.SupportsProviders());
1086 }
1087
1088 PVR_ERROR CPVRClient::GetChannelsAmount(int& iChannels) const
1089 {
1090   iChannels = -1;
1091   return DoAddonCall(__func__, [&iChannels](const AddonInstance* addon)
1092                      { return addon->toAddon->GetChannelsAmount(addon, &iChannels); });
1093 }
1094
1095 PVR_ERROR CPVRClient::GetChannels(bool radio,
1096                                   std::vector<std::shared_ptr<CPVRChannel>>& channels) const
1097 {
1098   return DoAddonCall(
1099       __func__,
1100       [this, radio, &channels](const AddonInstance* addon)
1101       {
1102         PVR_HANDLE_STRUCT handle = {};
1103         handle.callerAddress = this;
1104         handle.dataAddress = &channels;
1105         const PVR_ERROR error{addon->toAddon->GetChannels(addon, &handle, radio)};
1106
1107         if (error == PVR_ERROR_NO_ERROR)
1108         {
1109           const CDateTime& dateTime{GetDateTimeFirstChannelsAdded()};
1110           if (!dateTime.IsValid())
1111           {
1112             // Remember when first channels were added for this client.
1113             const_cast<CPVRClient*>(this)->SetDateTimeFirstChannelsAdded(
1114                 CDateTime::GetUTCDateTime());
1115           }
1116         }
1117
1118         return error;
1119       },
1120       (radio && m_clientCapabilities.SupportsRadio()) ||
1121           (!radio && m_clientCapabilities.SupportsTV()));
1122 }
1123
1124 PVR_ERROR CPVRClient::GetRecordingsAmount(bool deleted, int& iRecordings) const
1125 {
1126   iRecordings = -1;
1127   return DoAddonCall(
1128       __func__,
1129       [deleted, &iRecordings](const AddonInstance* addon)
1130       { return addon->toAddon->GetRecordingsAmount(addon, deleted, &iRecordings); },
1131       m_clientCapabilities.SupportsRecordings() &&
1132           (!deleted || m_clientCapabilities.SupportsRecordingsUndelete()));
1133 }
1134
1135 PVR_ERROR CPVRClient::GetRecordings(CPVRRecordings* results, bool deleted) const
1136 {
1137   return DoAddonCall(
1138       __func__,
1139       [this, results, deleted](const AddonInstance* addon)
1140       {
1141         PVR_HANDLE_STRUCT handle = {};
1142         handle.callerAddress = this;
1143         handle.dataAddress = results;
1144         return addon->toAddon->GetRecordings(addon, &handle, deleted);
1145       },
1146       m_clientCapabilities.SupportsRecordings() &&
1147           (!deleted || m_clientCapabilities.SupportsRecordingsUndelete()));
1148 }
1149
1150 PVR_ERROR CPVRClient::DeleteRecording(const CPVRRecording& recording)
1151 {
1152   return DoAddonCall(
1153       __func__,
1154       [&recording](const AddonInstance* addon)
1155       {
1156         const CAddonRecording tag{recording};
1157         return addon->toAddon->DeleteRecording(addon, &tag);
1158       },
1159       m_clientCapabilities.SupportsRecordings() && m_clientCapabilities.SupportsRecordingsDelete());
1160 }
1161
1162 PVR_ERROR CPVRClient::UndeleteRecording(const CPVRRecording& recording)
1163 {
1164   return DoAddonCall(
1165       __func__,
1166       [&recording](const AddonInstance* addon)
1167       {
1168         const CAddonRecording tag{recording};
1169         return addon->toAddon->UndeleteRecording(addon, &tag);
1170       },
1171       m_clientCapabilities.SupportsRecordingsUndelete());
1172 }
1173
1174 PVR_ERROR CPVRClient::DeleteAllRecordingsFromTrash()
1175 {
1176   return DoAddonCall(
1177       __func__,
1178       [](const AddonInstance* addon)
1179       { return addon->toAddon->DeleteAllRecordingsFromTrash(addon); },
1180       m_clientCapabilities.SupportsRecordingsUndelete());
1181 }
1182
1183 PVR_ERROR CPVRClient::RenameRecording(const CPVRRecording& recording)
1184 {
1185   return DoAddonCall(
1186       __func__,
1187       [&recording](const AddonInstance* addon)
1188       {
1189         const CAddonRecording tag{recording};
1190         return addon->toAddon->RenameRecording(addon, &tag);
1191       },
1192       m_clientCapabilities.SupportsRecordings());
1193 }
1194
1195 PVR_ERROR CPVRClient::SetRecordingLifetime(const CPVRRecording& recording)
1196 {
1197   return DoAddonCall(
1198       __func__,
1199       [&recording](const AddonInstance* addon)
1200       {
1201         const CAddonRecording tag{recording};
1202         return addon->toAddon->SetRecordingLifetime(addon, &tag);
1203       },
1204       m_clientCapabilities.SupportsRecordingsLifetimeChange());
1205 }
1206
1207 PVR_ERROR CPVRClient::SetRecordingPlayCount(const CPVRRecording& recording, int count)
1208 {
1209   return DoAddonCall(
1210       __func__,
1211       [&recording, count](const AddonInstance* addon)
1212       {
1213         const CAddonRecording tag{recording};
1214         return addon->toAddon->SetRecordingPlayCount(addon, &tag, count);
1215       },
1216       m_clientCapabilities.SupportsRecordingsPlayCount());
1217 }
1218
1219 PVR_ERROR CPVRClient::SetRecordingLastPlayedPosition(const CPVRRecording& recording,
1220                                                      int lastplayedposition)
1221 {
1222   return DoAddonCall(
1223       __func__,
1224       [&recording, lastplayedposition](const AddonInstance* addon)
1225       {
1226         const CAddonRecording tag{recording};
1227         return addon->toAddon->SetRecordingLastPlayedPosition(addon, &tag, lastplayedposition);
1228       },
1229       m_clientCapabilities.SupportsRecordingsLastPlayedPosition());
1230 }
1231
1232 PVR_ERROR CPVRClient::GetRecordingLastPlayedPosition(const CPVRRecording& recording,
1233                                                      int& iPosition) const
1234 {
1235   iPosition = -1;
1236   return DoAddonCall(
1237       __func__,
1238       [&recording, &iPosition](const AddonInstance* addon)
1239       {
1240         const CAddonRecording tag{recording};
1241         return addon->toAddon->GetRecordingLastPlayedPosition(addon, &tag, &iPosition);
1242       },
1243       m_clientCapabilities.SupportsRecordingsLastPlayedPosition());
1244 }
1245
1246 PVR_ERROR CPVRClient::GetRecordingEdl(const CPVRRecording& recording,
1247                                       std::vector<EDL::Edit>& edls) const
1248 {
1249   edls.clear();
1250   return DoAddonCall(
1251       __func__,
1252       [&recording, &edls](const AddonInstance* addon)
1253       {
1254         const CAddonRecording tag{recording};
1255
1256         PVR_EDL_ENTRY** edl_array{nullptr};
1257         unsigned int size{0};
1258         const PVR_ERROR error{addon->toAddon->GetRecordingEdl(addon, &tag, &edl_array, &size)};
1259         if (error == PVR_ERROR_NO_ERROR)
1260         {
1261           edls.reserve(size);
1262           for (unsigned int i = 0; i < size; ++i)
1263             edls.emplace_back(ConvertAddonEdl(*edl_array[i]));
1264         }
1265         addon->toAddon->FreeEdlEntries(addon, edl_array, size);
1266         return error;
1267       },
1268       m_clientCapabilities.SupportsRecordingsEdl());
1269 }
1270
1271 PVR_ERROR CPVRClient::GetRecordingSize(const CPVRRecording& recording, int64_t& sizeInBytes) const
1272 {
1273   return DoAddonCall(
1274       __func__,
1275       [&recording, &sizeInBytes](const AddonInstance* addon)
1276       {
1277         const CAddonRecording tag{recording};
1278         return addon->toAddon->GetRecordingSize(addon, &tag, &sizeInBytes);
1279       },
1280       m_clientCapabilities.SupportsRecordingsSize());
1281 }
1282
1283 PVR_ERROR CPVRClient::GetTimersAmount(int& iTimers) const
1284 {
1285   iTimers = -1;
1286   return DoAddonCall(
1287       __func__,
1288       [&iTimers](const AddonInstance* addon)
1289       { return addon->toAddon->GetTimersAmount(addon, &iTimers); },
1290       m_clientCapabilities.SupportsTimers());
1291 }
1292
1293 PVR_ERROR CPVRClient::GetTimers(CPVRTimersContainer* results) const
1294 {
1295   return DoAddonCall(
1296       __func__,
1297       [this, results](const AddonInstance* addon)
1298       {
1299         PVR_HANDLE_STRUCT handle = {};
1300         handle.callerAddress = this;
1301         handle.dataAddress = results;
1302         return addon->toAddon->GetTimers(addon, &handle);
1303       },
1304       m_clientCapabilities.SupportsTimers());
1305 }
1306
1307 PVR_ERROR CPVRClient::AddTimer(const CPVRTimerInfoTag& timer)
1308 {
1309   return DoAddonCall(
1310       __func__,
1311       [&timer](const AddonInstance* addon)
1312       {
1313         const CAddonTimer tag{timer};
1314         return addon->toAddon->AddTimer(addon, &tag);
1315       },
1316       m_clientCapabilities.SupportsTimers());
1317 }
1318
1319 PVR_ERROR CPVRClient::DeleteTimer(const CPVRTimerInfoTag& timer, bool bForce /* = false */)
1320 {
1321   return DoAddonCall(
1322       __func__,
1323       [&timer, bForce](const AddonInstance* addon)
1324       {
1325         const CAddonTimer tag{timer};
1326         return addon->toAddon->DeleteTimer(addon, &tag, bForce);
1327       },
1328       m_clientCapabilities.SupportsTimers());
1329 }
1330
1331 PVR_ERROR CPVRClient::UpdateTimer(const CPVRTimerInfoTag& timer)
1332 {
1333   return DoAddonCall(
1334       __func__,
1335       [&timer](const AddonInstance* addon)
1336       {
1337         const CAddonTimer tag{timer};
1338         return addon->toAddon->UpdateTimer(addon, &tag);
1339       },
1340       m_clientCapabilities.SupportsTimers());
1341 }
1342
1343 const std::vector<std::shared_ptr<CPVRTimerType>>& CPVRClient::GetTimerTypes() const
1344 {
1345   std::unique_lock<CCriticalSection> lock(m_critSection);
1346   return m_timertypes;
1347 }
1348
1349 PVR_ERROR CPVRClient::UpdateTimerTypes()
1350 {
1351   std::vector<std::shared_ptr<CPVRTimerType>> timerTypes;
1352
1353   PVR_ERROR retVal = DoAddonCall(
1354       __func__,
1355       [this, &timerTypes](const AddonInstance* addon)
1356       {
1357         PVR_TIMER_TYPE** types_array{nullptr};
1358         unsigned int size{0};
1359         PVR_ERROR retval{addon->toAddon->GetTimerTypes(addon, &types_array, &size)};
1360
1361         const bool array_owner{retval == PVR_ERROR_NOT_IMPLEMENTED};
1362         if (array_owner)
1363         {
1364           // begin compat section
1365           CLog::LogF(LOGWARNING,
1366                      "Add-on {} does not support timer types. It will work, but not benefit from "
1367                      "the timer features introduced with PVR Addon API 2.0.0",
1368                      Name());
1369
1370           // Create standard timer types (mostly) matching the timer functionality available in Isengard.
1371           // This is for migration only and does not make changes to the addons obsolete. Addons should
1372           // work and benefit from some UI changes (e.g. some of the timer settings dialog enhancements),
1373           // but all old problems/bugs due to static attributes and values will remain the same as in
1374           // Isengard. Also, new features (like epg search) are not available to addons automatically.
1375           // This code can be removed once all addons actually support the respective PVR Addon API version.
1376
1377           size = 2;
1378           if (m_clientCapabilities.SupportsEPG())
1379             size++;
1380
1381           types_array = new PVR_TIMER_TYPE*[size];
1382
1383           // manual one time
1384           types_array[0] = new PVR_TIMER_TYPE{};
1385           types_array[0]->iId = 1;
1386           types_array[0]->iAttributes =
1387               PVR_TIMER_TYPE_IS_MANUAL | PVR_TIMER_TYPE_SUPPORTS_ENABLE_DISABLE |
1388               PVR_TIMER_TYPE_SUPPORTS_CHANNELS | PVR_TIMER_TYPE_SUPPORTS_START_TIME |
1389               PVR_TIMER_TYPE_SUPPORTS_END_TIME | PVR_TIMER_TYPE_SUPPORTS_PRIORITY |
1390               PVR_TIMER_TYPE_SUPPORTS_LIFETIME | PVR_TIMER_TYPE_SUPPORTS_RECORDING_FOLDERS;
1391
1392           // manual timer rule
1393           types_array[1] = new PVR_TIMER_TYPE{};
1394           types_array[1]->iId = 2;
1395           types_array[1]->iAttributes =
1396               PVR_TIMER_TYPE_IS_MANUAL | PVR_TIMER_TYPE_IS_REPEATING |
1397               PVR_TIMER_TYPE_SUPPORTS_ENABLE_DISABLE | PVR_TIMER_TYPE_SUPPORTS_CHANNELS |
1398               PVR_TIMER_TYPE_SUPPORTS_START_TIME | PVR_TIMER_TYPE_SUPPORTS_END_TIME |
1399               PVR_TIMER_TYPE_SUPPORTS_PRIORITY | PVR_TIMER_TYPE_SUPPORTS_LIFETIME |
1400               PVR_TIMER_TYPE_SUPPORTS_FIRST_DAY | PVR_TIMER_TYPE_SUPPORTS_WEEKDAYS |
1401               PVR_TIMER_TYPE_SUPPORTS_RECORDING_FOLDERS;
1402
1403           if (m_clientCapabilities.SupportsEPG())
1404           {
1405             // One-shot epg-based
1406             types_array[2] = new PVR_TIMER_TYPE{};
1407             types_array[2]->iId = 3;
1408             types_array[2]->iAttributes =
1409                 PVR_TIMER_TYPE_SUPPORTS_ENABLE_DISABLE | PVR_TIMER_TYPE_REQUIRES_EPG_TAG_ON_CREATE |
1410                 PVR_TIMER_TYPE_SUPPORTS_CHANNELS | PVR_TIMER_TYPE_SUPPORTS_START_TIME |
1411                 PVR_TIMER_TYPE_SUPPORTS_END_TIME | PVR_TIMER_TYPE_SUPPORTS_PRIORITY |
1412                 PVR_TIMER_TYPE_SUPPORTS_LIFETIME | PVR_TIMER_TYPE_SUPPORTS_RECORDING_FOLDERS;
1413           }
1414
1415           retval = PVR_ERROR_NO_ERROR;
1416           // end compat section
1417         }
1418
1419         if (retval == PVR_ERROR_NO_ERROR)
1420         {
1421           timerTypes.reserve(size);
1422           for (unsigned int i = 0; i < size; ++i)
1423           {
1424             if (types_array[i]->iId == PVR_TIMER_TYPE_NONE)
1425             {
1426               CLog::LogF(LOGERROR, "Invalid timer type supplied by add-on {}.", GetID());
1427               continue;
1428             }
1429             timerTypes.emplace_back(
1430                 std::make_shared<CPVRTimerType>(*(types_array[i]), m_iClientId));
1431           }
1432         }
1433
1434         /* free the resources of the timer types array */
1435         if (array_owner)
1436         {
1437           // begin compat section
1438           for (unsigned int i = 0; i < size; ++i)
1439             delete types_array[i];
1440
1441           delete[] types_array;
1442           // end compat section
1443         }
1444         else
1445         {
1446           addon->toAddon->FreeTimerTypes(addon, types_array, size);
1447         }
1448         types_array = nullptr;
1449
1450         return retval;
1451       },
1452       m_clientCapabilities.SupportsTimers(), false);
1453
1454   if (retVal == PVR_ERROR_NO_ERROR)
1455   {
1456     std::vector<std::shared_ptr<CPVRTimerType>> newTimerTypes;
1457     newTimerTypes.reserve(timerTypes.size());
1458
1459     std::unique_lock<CCriticalSection> lock(m_critSection);
1460
1461     for (const auto& type : timerTypes)
1462     {
1463       const auto it = std::find_if(m_timertypes.cbegin(), m_timertypes.cend(),
1464                                    [&type](const std::shared_ptr<const CPVRTimerType>& entry)
1465                                    { return entry->GetTypeId() == type->GetTypeId(); });
1466       if (it == m_timertypes.cend())
1467       {
1468         newTimerTypes.emplace_back(type);
1469       }
1470       else
1471       {
1472         (*it)->Update(*type);
1473         newTimerTypes.emplace_back(*it);
1474       }
1475     }
1476
1477     m_timertypes = newTimerTypes;
1478   }
1479   return retVal;
1480 }
1481
1482 PVR_ERROR CPVRClient::GetStreamReadChunkSize(int& iChunkSize) const
1483 {
1484   return DoAddonCall(
1485       __func__,
1486       [&iChunkSize](const AddonInstance* addon)
1487       { return addon->toAddon->GetStreamReadChunkSize(addon, &iChunkSize); },
1488       m_clientCapabilities.SupportsRecordings() || m_clientCapabilities.HandlesInputStream());
1489 }
1490
1491 PVR_ERROR CPVRClient::ReadLiveStream(void* lpBuf, int64_t uiBufSize, int& iRead)
1492 {
1493   iRead = -1;
1494   return DoAddonCall(__func__,
1495                      [&lpBuf, uiBufSize, &iRead](const AddonInstance* addon)
1496                      {
1497                        iRead = addon->toAddon->ReadLiveStream(
1498                            addon, static_cast<unsigned char*>(lpBuf), static_cast<int>(uiBufSize));
1499                        return (iRead == -1) ? PVR_ERROR_NOT_IMPLEMENTED : PVR_ERROR_NO_ERROR;
1500                      });
1501 }
1502
1503 PVR_ERROR CPVRClient::ReadRecordedStream(int64_t streamId,
1504                                          void* lpBuf,
1505                                          int64_t uiBufSize,
1506                                          int& iRead)
1507 {
1508   iRead = -1;
1509   return DoAddonCall(__func__,
1510                      [streamId, &lpBuf, uiBufSize, &iRead](const AddonInstance* addon)
1511                      {
1512                        iRead = addon->toAddon->ReadRecordedStream(
1513                            addon, streamId, static_cast<unsigned char*>(lpBuf),
1514                            static_cast<int>(uiBufSize));
1515                        return (iRead == -1) ? PVR_ERROR_NOT_IMPLEMENTED : PVR_ERROR_NO_ERROR;
1516                      });
1517 }
1518
1519 PVR_ERROR CPVRClient::SeekLiveStream(int64_t iFilePosition, int iWhence, int64_t& iPosition)
1520 {
1521   iPosition = -1;
1522   return DoAddonCall(__func__,
1523                      [iFilePosition, iWhence, &iPosition](const AddonInstance* addon)
1524                      {
1525                        iPosition = addon->toAddon->SeekLiveStream(addon, iFilePosition, iWhence);
1526                        return (iPosition == -1) ? PVR_ERROR_NOT_IMPLEMENTED : PVR_ERROR_NO_ERROR;
1527                      });
1528 }
1529
1530 PVR_ERROR CPVRClient::SeekRecordedStream(int64_t streamId,
1531                                          int64_t iFilePosition,
1532                                          int iWhence,
1533                                          int64_t& iPosition)
1534 {
1535   iPosition = -1;
1536   return DoAddonCall(__func__,
1537                      [streamId, iFilePosition, iWhence, &iPosition](const AddonInstance* addon)
1538                      {
1539                        iPosition = addon->toAddon->SeekRecordedStream(addon, streamId,
1540                                                                       iFilePosition, iWhence);
1541                        return (iPosition == -1) ? PVR_ERROR_NOT_IMPLEMENTED : PVR_ERROR_NO_ERROR;
1542                      });
1543 }
1544
1545 PVR_ERROR CPVRClient::SeekTime(double time, bool backwards, double* startpts)
1546 {
1547   return DoAddonCall(__func__,
1548                      [time, backwards, &startpts](const AddonInstance* addon)
1549                      {
1550                        return addon->toAddon->SeekTime(addon, time, backwards, startpts)
1551                                   ? PVR_ERROR_NO_ERROR
1552                                   : PVR_ERROR_NOT_IMPLEMENTED;
1553                      });
1554 }
1555
1556 PVR_ERROR CPVRClient::GetLiveStreamLength(int64_t& iLength) const
1557 {
1558   iLength = -1;
1559   return DoAddonCall(__func__,
1560                      [&iLength](const AddonInstance* addon)
1561                      {
1562                        iLength = addon->toAddon->LengthLiveStream(addon);
1563                        return (iLength == -1) ? PVR_ERROR_NOT_IMPLEMENTED : PVR_ERROR_NO_ERROR;
1564                      });
1565 }
1566
1567 PVR_ERROR CPVRClient::GetRecordedStreamLength(int64_t streamId, int64_t& iLength) const
1568 {
1569   iLength = -1;
1570   return DoAddonCall(__func__,
1571                      [streamId, &iLength](const AddonInstance* addon)
1572                      {
1573                        iLength = addon->toAddon->LengthRecordedStream(addon, streamId);
1574                        return (iLength == -1) ? PVR_ERROR_NOT_IMPLEMENTED : PVR_ERROR_NO_ERROR;
1575                      });
1576 }
1577
1578 PVR_ERROR CPVRClient::SignalQuality(int channelUid, CPVRSignalStatus& qualityinfo) const
1579 {
1580   return DoAddonCall(__func__,
1581                      [channelUid, &qualityinfo](const AddonInstance* addon)
1582                      {
1583                        PVR_SIGNAL_STATUS info{};
1584                        const PVR_ERROR error{
1585                            addon->toAddon->GetSignalStatus(addon, channelUid, &info)};
1586                        if (error == PVR_ERROR_NO_ERROR)
1587                          qualityinfo = CPVRSignalStatus{info};
1588
1589                        addon->toAddon->FreeSignalStatus(addon, &info);
1590                        return error;
1591                      });
1592 }
1593
1594 PVR_ERROR CPVRClient::GetDescrambleInfo(int channelUid, CPVRDescrambleInfo& descrambleinfo) const
1595 {
1596   return DoAddonCall(
1597       __func__,
1598       [channelUid, &descrambleinfo](const AddonInstance* addon)
1599       {
1600         PVR_DESCRAMBLE_INFO info{};
1601         const PVR_ERROR error{addon->toAddon->GetDescrambleInfo(addon, channelUid, &info)};
1602         if (error == PVR_ERROR_NO_ERROR)
1603           descrambleinfo = CPVRDescrambleInfo{info};
1604
1605         addon->toAddon->FreeDescrambleInfo(addon, &info);
1606         return error;
1607       },
1608       m_clientCapabilities.SupportsDescrambleInfo());
1609 }
1610
1611 PVR_ERROR CPVRClient::GetChannelStreamProperties(const std::shared_ptr<const CPVRChannel>& channel,
1612                                                  PVR_SOURCE source,
1613                                                  CPVRStreamProperties& props) const
1614 {
1615   return DoAddonCall(
1616       __func__,
1617       [this, &channel, source, &props](const AddonInstance* addon)
1618       {
1619         if (!CanPlayChannel(channel))
1620           return PVR_ERROR_NO_ERROR; // no error, but no need to obtain the values from the addon
1621
1622         const CAddonChannel addonChannel{*channel};
1623
1624         PVR_NAMED_VALUE** property_array{nullptr};
1625         unsigned int size{0};
1626         const PVR_ERROR error{addon->toAddon->GetChannelStreamProperties(
1627             addon, &addonChannel, source, &property_array, &size)};
1628         if (error == PVR_ERROR_NO_ERROR)
1629           WriteStreamProperties(property_array, size, props);
1630
1631         addon->toAddon->FreeProperties(addon, property_array, size);
1632         return error;
1633       });
1634 }
1635
1636 PVR_ERROR CPVRClient::GetRecordingStreamProperties(
1637     const std::shared_ptr<const CPVRRecording>& recording, CPVRStreamProperties& props) const
1638 {
1639   return DoAddonCall(
1640       __func__,
1641       [this, &recording, &props](const AddonInstance* addon)
1642       {
1643         if (!m_clientCapabilities.SupportsRecordings())
1644           return PVR_ERROR_NO_ERROR; // no error, but no need to obtain the values from the addon
1645
1646         const CAddonRecording addonRecording(*recording);
1647
1648         PVR_NAMED_VALUE** property_array{nullptr};
1649         unsigned int size{0};
1650         const PVR_ERROR error{addon->toAddon->GetRecordingStreamProperties(addon, &addonRecording,
1651                                                                            &property_array, &size)};
1652         if (error == PVR_ERROR_NO_ERROR)
1653           WriteStreamProperties(property_array, size, props);
1654
1655         addon->toAddon->FreeProperties(addon, property_array, size);
1656         return error;
1657       });
1658 }
1659
1660 PVR_ERROR CPVRClient::GetStreamProperties(PVR_STREAM_PROPERTIES* props) const
1661 {
1662   return DoAddonCall(__func__, [&props](const AddonInstance* addon)
1663                      { return addon->toAddon->GetStreamProperties(addon, props); });
1664 }
1665
1666 PVR_ERROR CPVRClient::StreamClosed() const
1667 {
1668   return DoAddonCall(__func__, [](const AddonInstance* addon)
1669                      { return addon->toAddon->StreamClosed(addon); });
1670 }
1671
1672 PVR_ERROR CPVRClient::DemuxReset()
1673 {
1674   return DoAddonCall(
1675       __func__,
1676       [](const AddonInstance* addon)
1677       {
1678         addon->toAddon->DemuxReset(addon);
1679         return PVR_ERROR_NO_ERROR;
1680       },
1681       m_clientCapabilities.HandlesDemuxing());
1682 }
1683
1684 PVR_ERROR CPVRClient::DemuxAbort()
1685 {
1686   return DoAddonCall(
1687       __func__,
1688       [](const AddonInstance* addon)
1689       {
1690         addon->toAddon->DemuxAbort(addon);
1691         return PVR_ERROR_NO_ERROR;
1692       },
1693       m_clientCapabilities.HandlesDemuxing());
1694 }
1695
1696 PVR_ERROR CPVRClient::DemuxFlush()
1697 {
1698   return DoAddonCall(
1699       __func__,
1700       [](const AddonInstance* addon)
1701       {
1702         addon->toAddon->DemuxFlush(addon);
1703         return PVR_ERROR_NO_ERROR;
1704       },
1705       m_clientCapabilities.HandlesDemuxing());
1706 }
1707
1708 PVR_ERROR CPVRClient::DemuxRead(DemuxPacket*& packet)
1709 {
1710   return DoAddonCall(
1711       __func__,
1712       [&packet](const AddonInstance* addon)
1713       {
1714         packet = static_cast<DemuxPacket*>(addon->toAddon->DemuxRead(addon));
1715         return packet ? PVR_ERROR_NO_ERROR : PVR_ERROR_NOT_IMPLEMENTED;
1716       },
1717       m_clientCapabilities.HandlesDemuxing());
1718 }
1719
1720 const char* CPVRClient::ToString(const PVR_ERROR error)
1721 {
1722   switch (error)
1723   {
1724     case PVR_ERROR_NO_ERROR:
1725       return "no error";
1726     case PVR_ERROR_NOT_IMPLEMENTED:
1727       return "not implemented";
1728     case PVR_ERROR_SERVER_ERROR:
1729       return "server error";
1730     case PVR_ERROR_SERVER_TIMEOUT:
1731       return "server timeout";
1732     case PVR_ERROR_RECORDING_RUNNING:
1733       return "recording already running";
1734     case PVR_ERROR_ALREADY_PRESENT:
1735       return "already present";
1736     case PVR_ERROR_REJECTED:
1737       return "rejected by the backend";
1738     case PVR_ERROR_INVALID_PARAMETERS:
1739       return "invalid parameters for this method";
1740     case PVR_ERROR_FAILED:
1741       return "the command failed";
1742     case PVR_ERROR_UNKNOWN:
1743     default:
1744       return "unknown error";
1745   }
1746 }
1747
1748 PVR_ERROR CPVRClient::DoAddonCall(const char* strFunctionName,
1749                                   const std::function<PVR_ERROR(const AddonInstance*)>& function,
1750                                   bool bIsImplemented /* = true */,
1751                                   bool bCheckReadyToUse /* = true */) const
1752 {
1753   // Check preconditions.
1754   if (!bIsImplemented)
1755     return PVR_ERROR_NOT_IMPLEMENTED;
1756
1757   if (m_bBlockAddonCalls)
1758   {
1759     CLog::Log(LOGWARNING, "{}: Blocking call to add-on {}.", strFunctionName, GetID());
1760     return PVR_ERROR_SERVER_ERROR;
1761   }
1762
1763   if (bCheckReadyToUse && IgnoreClient())
1764   {
1765     CLog::Log(LOGWARNING, "{}: Blocking call to add-on {}. Add-on not (yet) connected.",
1766               strFunctionName, GetID());
1767     return PVR_ERROR_SERVER_ERROR;
1768   }
1769
1770   if (bCheckReadyToUse && !ReadyToUse())
1771   {
1772     CLog::Log(LOGWARNING, "{}: Blocking call to add-on {}. Add-on not ready to use.",
1773               strFunctionName, GetID());
1774     return PVR_ERROR_SERVER_ERROR;
1775   }
1776
1777   // Call.
1778   m_allAddonCallsFinished.Reset();
1779   m_iAddonCalls++;
1780
1781   //  CLog::LogFC(LOGDEBUG, LOGPVR, "Calling add-on function '{}' on client {}.", strFunctionName,
1782   //              GetID());
1783
1784   const PVR_ERROR error = function(m_ifc.pvr);
1785
1786   //  CLog::LogFC(LOGDEBUG, LOGPVR, "Called add-on function '{}' on client {}. return={}",
1787   //              strFunctionName, GetID(), error);
1788
1789   m_iAddonCalls--;
1790   if (m_iAddonCalls == 0)
1791     m_allAddonCallsFinished.Set();
1792
1793   // Log error, if any.
1794   if (error != PVR_ERROR_NO_ERROR && error != PVR_ERROR_NOT_IMPLEMENTED)
1795     CLog::Log(LOGERROR, "{}: Add-on {} returned an error: {}", strFunctionName, GetID(),
1796               ToString(error));
1797
1798   return error;
1799 }
1800
1801 bool CPVRClient::CanPlayChannel(const std::shared_ptr<const CPVRChannel>& channel) const
1802 {
1803   return (m_bReadyToUse && ((m_clientCapabilities.SupportsTV() && !channel->IsRadio()) ||
1804                             (m_clientCapabilities.SupportsRadio() && channel->IsRadio())));
1805 }
1806
1807 PVR_ERROR CPVRClient::OpenLiveStream(const std::shared_ptr<const CPVRChannel>& channel)
1808 {
1809   if (!channel)
1810     return PVR_ERROR_INVALID_PARAMETERS;
1811
1812   return DoAddonCall(__func__,
1813                      [this, channel](const AddonInstance* addon)
1814                      {
1815                        CloseLiveStream();
1816
1817                        if (!CanPlayChannel(channel))
1818                        {
1819                          CLog::LogFC(LOGDEBUG, LOGPVR, "Add-on {} can not play channel '{}'",
1820                                      GetID(), channel->ChannelName());
1821                          return PVR_ERROR_SERVER_ERROR;
1822                        }
1823                        else
1824                        {
1825                          CLog::LogFC(LOGDEBUG, LOGPVR, "Opening live stream for channel '{}'",
1826                                      channel->ChannelName());
1827                          const CAddonChannel addonChannel{*channel};
1828                          return addon->toAddon->OpenLiveStream(addon, &addonChannel)
1829                                     ? PVR_ERROR_NO_ERROR
1830                                     : PVR_ERROR_NOT_IMPLEMENTED;
1831                        }
1832                      });
1833 }
1834
1835 PVR_ERROR CPVRClient::OpenRecordedStream(const std::shared_ptr<const CPVRRecording>& recording,
1836                                          int64_t& streamId)
1837 {
1838   if (!recording)
1839     return PVR_ERROR_INVALID_PARAMETERS;
1840
1841   return DoAddonCall(
1842       __func__,
1843       [this, recording, &streamId](const AddonInstance* addon)
1844       {
1845         if (!m_clientCapabilities.SupportsMultipleRecordedStreams())
1846           CloseRecordedStream(streamId);
1847
1848         const CAddonRecording tag(*recording);
1849         CLog::LogFC(LOGDEBUG, LOGPVR, "Opening stream for recording '{}'", recording->m_strTitle);
1850         return addon->toAddon->OpenRecordedStream(addon, &tag, &streamId)
1851                    ? PVR_ERROR_NO_ERROR
1852                    : PVR_ERROR_NOT_IMPLEMENTED;
1853       },
1854       m_clientCapabilities.SupportsRecordings());
1855 }
1856
1857 PVR_ERROR CPVRClient::CloseLiveStream()
1858 {
1859   return DoAddonCall(__func__,
1860                      [](const AddonInstance* addon)
1861                      {
1862                        addon->toAddon->CloseLiveStream(addon);
1863                        return PVR_ERROR_NO_ERROR;
1864                      });
1865 }
1866
1867 PVR_ERROR CPVRClient::CloseRecordedStream(int64_t streamId)
1868 {
1869   return DoAddonCall(__func__,
1870                      [streamId](const AddonInstance* addon)
1871                      {
1872                        addon->toAddon->CloseRecordedStream(addon, streamId);
1873                        return PVR_ERROR_NO_ERROR;
1874                      });
1875 }
1876
1877 PVR_ERROR CPVRClient::IsRecordedStreamRealTime(int64_t streamId, bool& isRealTime) const
1878 {
1879   if (m_clientCapabilities.SupportsMultipleRecordedStreams())
1880   {
1881     return DoAddonCall(
1882         __func__, [streamId, &isRealTime](const AddonInstance* addon)
1883         { return addon->toAddon->IsRecordedStreamRealTime(addon, streamId, &isRealTime); });
1884   }
1885   else
1886   {
1887     return IsRealTimeStream(isRealTime);
1888   }
1889 }
1890
1891 PVR_ERROR CPVRClient::PauseRecordedStream(int64_t streamId, bool paused)
1892 {
1893   if (m_clientCapabilities.SupportsMultipleRecordedStreams())
1894   {
1895     return DoAddonCall(__func__, [streamId, paused](const AddonInstance* addon)
1896                        { return addon->toAddon->PauseRecordedStream(addon, streamId, paused); });
1897   }
1898   else
1899   {
1900     return PauseStream(paused);
1901   }
1902 }
1903
1904 PVR_ERROR CPVRClient::GetRecordedStreamTimes(int64_t streamId, PVR_STREAM_TIMES* times) const
1905 {
1906   if (m_clientCapabilities.SupportsMultipleRecordedStreams())
1907   {
1908     return DoAddonCall(__func__, [streamId, &times](const AddonInstance* addon)
1909                        { return addon->toAddon->GetRecordedStreamTimes(addon, streamId, times); });
1910   }
1911   else
1912   {
1913     return GetStreamTimes(times);
1914   }
1915 }
1916
1917 PVR_ERROR CPVRClient::PauseStream(bool bPaused)
1918 {
1919   return DoAddonCall(__func__,
1920                      [bPaused](const AddonInstance* addon)
1921                      {
1922                        addon->toAddon->PauseStream(addon, bPaused);
1923                        return PVR_ERROR_NO_ERROR;
1924                      });
1925 }
1926
1927 PVR_ERROR CPVRClient::SetSpeed(int speed)
1928 {
1929   return DoAddonCall(__func__,
1930                      [speed](const AddonInstance* addon)
1931                      {
1932                        addon->toAddon->SetSpeed(addon, speed);
1933                        return PVR_ERROR_NO_ERROR;
1934                      });
1935 }
1936
1937 PVR_ERROR CPVRClient::FillBuffer(bool mode)
1938 {
1939   return DoAddonCall(__func__,
1940                      [mode](const AddonInstance* addon)
1941                      {
1942                        addon->toAddon->FillBuffer(addon, mode);
1943                        return PVR_ERROR_NO_ERROR;
1944                      });
1945 }
1946
1947 PVR_ERROR CPVRClient::CanPauseStream(bool& bCanPause) const
1948 {
1949   bCanPause = false;
1950   return DoAddonCall(__func__,
1951                      [&bCanPause](const AddonInstance* addon)
1952                      {
1953                        bCanPause = addon->toAddon->CanPauseStream(addon);
1954                        return PVR_ERROR_NO_ERROR;
1955                      });
1956 }
1957
1958 PVR_ERROR CPVRClient::CanSeekStream(bool& bCanSeek) const
1959 {
1960   bCanSeek = false;
1961   return DoAddonCall(__func__,
1962                      [&bCanSeek](const AddonInstance* addon)
1963                      {
1964                        bCanSeek = addon->toAddon->CanSeekStream(addon);
1965                        return PVR_ERROR_NO_ERROR;
1966                      });
1967 }
1968
1969 PVR_ERROR CPVRClient::GetStreamTimes(PVR_STREAM_TIMES* times) const
1970 {
1971   return DoAddonCall(__func__, [&times](const AddonInstance* addon)
1972                      { return addon->toAddon->GetStreamTimes(addon, times); });
1973 }
1974
1975 PVR_ERROR CPVRClient::IsRealTimeStream(bool& bRealTime) const
1976 {
1977   bRealTime = false;
1978   return DoAddonCall(__func__,
1979                      [&bRealTime](const AddonInstance* addon)
1980                      {
1981                        bRealTime = addon->toAddon->IsRealTimeStream(addon);
1982                        return PVR_ERROR_NO_ERROR;
1983                      });
1984 }
1985
1986 PVR_ERROR CPVRClient::OnSystemSleep()
1987 {
1988   return DoAddonCall(__func__, [](const AddonInstance* addon)
1989                      { return addon->toAddon->OnSystemSleep(addon); });
1990 }
1991
1992 PVR_ERROR CPVRClient::OnSystemWake()
1993 {
1994   return DoAddonCall(__func__, [](const AddonInstance* addon)
1995                      { return addon->toAddon->OnSystemWake(addon); });
1996 }
1997
1998 PVR_ERROR CPVRClient::OnPowerSavingActivated()
1999 {
2000   return DoAddonCall(__func__, [](const AddonInstance* addon)
2001                      { return addon->toAddon->OnPowerSavingActivated(addon); });
2002 }
2003
2004 PVR_ERROR CPVRClient::OnPowerSavingDeactivated()
2005 {
2006   return DoAddonCall(__func__, [](const AddonInstance* addon)
2007                      { return addon->toAddon->OnPowerSavingDeactivated(addon); });
2008 }
2009
2010 std::shared_ptr<CPVRClientMenuHooks> CPVRClient::GetMenuHooks() const
2011 {
2012   if (!m_menuhooks)
2013     m_menuhooks = std::make_shared<CPVRClientMenuHooks>(ID());
2014
2015   return m_menuhooks;
2016 }
2017
2018 PVR_ERROR CPVRClient::CallEpgTagMenuHook(const CPVRClientMenuHook& hook,
2019                                          const std::shared_ptr<const CPVREpgInfoTag>& tag)
2020 {
2021   return DoAddonCall(__func__,
2022                      [&hook, &tag](const AddonInstance* addon)
2023                      {
2024                        CAddonEpgTag addonTag(*tag);
2025
2026                        PVR_MENUHOOK menuHook;
2027                        menuHook.category = PVR_MENUHOOK_EPG;
2028                        menuHook.iHookId = hook.GetId();
2029                        menuHook.iLocalizedStringId = hook.GetLabelId();
2030
2031                        return addon->toAddon->CallEPGMenuHook(addon, &menuHook, &addonTag);
2032                      });
2033 }
2034
2035 PVR_ERROR CPVRClient::CallChannelMenuHook(const CPVRClientMenuHook& hook,
2036                                           const std::shared_ptr<const CPVRChannel>& channel)
2037 {
2038   return DoAddonCall(__func__,
2039                      [&hook, &channel](const AddonInstance* addon)
2040                      {
2041                        const CAddonChannel addonChannel{*channel};
2042
2043                        PVR_MENUHOOK menuHook;
2044                        menuHook.category = PVR_MENUHOOK_CHANNEL;
2045                        menuHook.iHookId = hook.GetId();
2046                        menuHook.iLocalizedStringId = hook.GetLabelId();
2047
2048                        return addon->toAddon->CallChannelMenuHook(addon, &menuHook, &addonChannel);
2049                      });
2050 }
2051
2052 PVR_ERROR CPVRClient::CallRecordingMenuHook(const CPVRClientMenuHook& hook,
2053                                             const std::shared_ptr<const CPVRRecording>& recording,
2054                                             bool bDeleted)
2055 {
2056   return DoAddonCall(__func__,
2057                      [&hook, &recording, &bDeleted](const AddonInstance* addon)
2058                      {
2059                        const CAddonRecording tag(*recording);
2060
2061                        PVR_MENUHOOK menuHook;
2062                        menuHook.category =
2063                            bDeleted ? PVR_MENUHOOK_DELETED_RECORDING : PVR_MENUHOOK_RECORDING;
2064                        menuHook.iHookId = hook.GetId();
2065                        menuHook.iLocalizedStringId = hook.GetLabelId();
2066
2067                        return addon->toAddon->CallRecordingMenuHook(addon, &menuHook, &tag);
2068                      });
2069 }
2070
2071 PVR_ERROR CPVRClient::CallTimerMenuHook(const CPVRClientMenuHook& hook,
2072                                         const std::shared_ptr<const CPVRTimerInfoTag>& timer)
2073 {
2074   return DoAddonCall(__func__,
2075                      [&hook, &timer](const AddonInstance* addon)
2076                      {
2077                        const CAddonTimer tag(*timer);
2078
2079                        PVR_MENUHOOK menuHook;
2080                        menuHook.category = PVR_MENUHOOK_TIMER;
2081                        menuHook.iHookId = hook.GetId();
2082                        menuHook.iLocalizedStringId = hook.GetLabelId();
2083
2084                        return addon->toAddon->CallTimerMenuHook(addon, &menuHook, &tag);
2085                      });
2086 }
2087
2088 PVR_ERROR CPVRClient::CallSettingsMenuHook(const CPVRClientMenuHook& hook)
2089 {
2090   return DoAddonCall(__func__,
2091                      [&hook](const AddonInstance* addon)
2092                      {
2093                        PVR_MENUHOOK menuHook;
2094                        menuHook.category = PVR_MENUHOOK_SETTING;
2095                        menuHook.iHookId = hook.GetId();
2096                        menuHook.iLocalizedStringId = hook.GetLabelId();
2097
2098                        return addon->toAddon->CallSettingsMenuHook(addon, &menuHook);
2099                      });
2100 }
2101
2102 void CPVRClient::SetPriority(int iPriority)
2103 {
2104   std::unique_lock<CCriticalSection> lock(m_critSection);
2105   if (m_priority != iPriority)
2106   {
2107     m_priority = iPriority;
2108     if (m_iClientId != PVR_CLIENT_INVALID_UID)
2109     {
2110       CServiceBroker::GetPVRManager().GetTVDatabase()->Persist(*this);
2111     }
2112     CServiceBroker::GetPVRManager().PublishEvent(PVREvent::ClientsPrioritiesInvalidated);
2113   }
2114 }
2115
2116 int CPVRClient::GetPriority() const
2117 {
2118   std::unique_lock<CCriticalSection> lock(m_critSection);
2119   if (!m_priority.has_value() && m_iClientId != PVR_CLIENT_INVALID_UID)
2120   {
2121     m_priority = CServiceBroker::GetPVRManager().GetTVDatabase()->GetPriority(*this);
2122   }
2123   return *m_priority;
2124 }
2125
2126 const CDateTime& CPVRClient::GetDateTimeFirstChannelsAdded() const
2127 {
2128   std::unique_lock<CCriticalSection> lock(m_critSection);
2129   if (!m_firstChannelsAdded.has_value() && m_iClientId != PVR_CLIENT_INVALID_UID)
2130   {
2131     m_firstChannelsAdded =
2132         CServiceBroker::GetPVRManager().GetTVDatabase()->GetDateTimeFirstChannelsAdded(*this);
2133   }
2134   return *m_firstChannelsAdded;
2135 }
2136
2137 void CPVRClient::SetDateTimeFirstChannelsAdded(const CDateTime& dateTime)
2138 {
2139   std::unique_lock<CCriticalSection> lock(m_critSection);
2140   if (m_firstChannelsAdded != dateTime)
2141   {
2142     m_firstChannelsAdded = dateTime;
2143     if (m_iClientId != PVR_CLIENT_INVALID_UID)
2144     {
2145       CServiceBroker::GetPVRManager().GetTVDatabase()->Persist(*this);
2146     }
2147   }
2148 }
2149
2150 void CPVRClient::HandleAddonCallback(const char* strFunctionName,
2151                                      void* kodiInstance,
2152                                      const std::function<void(CPVRClient* client)>& function,
2153                                      bool bForceCall /* = false */)
2154 {
2155   // Check preconditions.
2156   CPVRClient* client = static_cast<CPVRClient*>(kodiInstance);
2157   if (!client)
2158   {
2159     CLog::Log(LOGERROR, "{}: No instance pointer given!", strFunctionName);
2160     return;
2161   }
2162
2163   if (!bForceCall && client->m_bBlockAddonCalls && client->m_iAddonCalls == 0)
2164   {
2165     CLog::Log(LOGWARNING, LOGPVR, "{}: Ignoring callback from PVR client '{}'", strFunctionName,
2166               client->ID());
2167     return;
2168   }
2169
2170   // Call.
2171   function(client);
2172 }
2173
2174 void CPVRClient::cb_transfer_channel_group(void* kodiInstance,
2175                                            const PVR_HANDLE handle,
2176                                            const PVR_CHANNEL_GROUP* group)
2177 {
2178   HandleAddonCallback(__func__, kodiInstance,
2179                       [&](CPVRClient* client)
2180                       {
2181                         if (!handle || !group)
2182                         {
2183                           CLog::LogF(LOGERROR, "Invalid callback parameter(s)");
2184                           return;
2185                         }
2186
2187                         if (strlen(group->strGroupName) == 0)
2188                         {
2189                           CLog::LogF(LOGERROR, "Empty group name");
2190                           return;
2191                         }
2192
2193                         // transfer this entry to the groups container
2194                         CPVRChannelGroups* kodiGroups =
2195                             static_cast<CPVRChannelGroups*>(handle->dataAddress);
2196                         const auto transferGroup = kodiGroups->GetGroupFactory()->CreateClientGroup(
2197                             *group, client->GetID(), kodiGroups->GetGroupAll());
2198                         kodiGroups->UpdateFromClient(transferGroup);
2199                       });
2200 }
2201
2202 void CPVRClient::cb_transfer_channel_group_member(void* kodiInstance,
2203                                                   const PVR_HANDLE handle,
2204                                                   const PVR_CHANNEL_GROUP_MEMBER* member)
2205 {
2206   HandleAddonCallback(__func__, kodiInstance,
2207                       [&](CPVRClient* client)
2208                       {
2209                         if (!handle || !member)
2210                         {
2211                           CLog::LogF(LOGERROR, "Invalid callback parameter(s)");
2212                           return;
2213                         }
2214
2215                         const std::shared_ptr<CPVRChannel> channel =
2216                             CServiceBroker::GetPVRManager().ChannelGroups()->GetByUniqueID(
2217                                 member->iChannelUniqueId, client->GetID());
2218                         if (!channel)
2219                         {
2220                           CLog::LogF(LOGERROR, "Cannot find group '{}' or channel '{}'",
2221                                      member->strGroupName, member->iChannelUniqueId);
2222                         }
2223                         else
2224                         {
2225                           auto* groupMembers =
2226                               static_cast<std::vector<std::shared_ptr<CPVRChannelGroupMember>>*>(
2227                                   handle->dataAddress);
2228                           groupMembers->emplace_back(std::make_shared<CPVRChannelGroupMember>(
2229                               member->strGroupName, client->GetID(), member->iOrder, channel));
2230                         }
2231                       });
2232 }
2233
2234 void CPVRClient::cb_transfer_epg_entry(void* kodiInstance,
2235                                        const PVR_HANDLE handle,
2236                                        const EPG_TAG* epgentry)
2237 {
2238   HandleAddonCallback(__func__, kodiInstance,
2239                       [&](CPVRClient* client)
2240                       {
2241                         if (!handle || !epgentry)
2242                         {
2243                           CLog::LogF(LOGERROR, "Invalid callback parameter(s)");
2244                           return;
2245                         }
2246
2247                         // transfer this entry to the epg
2248                         CPVREpg* epg = static_cast<CPVREpg*>(handle->dataAddress);
2249                         epg->UpdateEntry(epgentry, client->GetID());
2250                       });
2251 }
2252
2253 void CPVRClient::cb_transfer_provider_entry(void* kodiInstance,
2254                                             const PVR_HANDLE handle,
2255                                             const PVR_PROVIDER* provider)
2256 {
2257   if (!handle)
2258   {
2259     CLog::LogF(LOGERROR, "Invalid handler data");
2260     return;
2261   }
2262
2263   CPVRClient* client = static_cast<CPVRClient*>(kodiInstance);
2264   CPVRProvidersContainer* kodiProviders = static_cast<CPVRProvidersContainer*>(handle->dataAddress);
2265   if (!provider || !client || !kodiProviders)
2266   {
2267     CLog::LogF(LOGERROR, "Invalid handler data");
2268     return;
2269   }
2270
2271   /* transfer this entry to the internal channels group */
2272   std::shared_ptr<CPVRProvider> transferProvider(
2273       std::make_shared<CPVRProvider>(*provider, client->GetID()));
2274   kodiProviders->UpdateFromClient(transferProvider);
2275 }
2276
2277 void CPVRClient::cb_transfer_channel_entry(void* kodiInstance,
2278                                            const PVR_HANDLE handle,
2279                                            const PVR_CHANNEL* channel)
2280 {
2281   HandleAddonCallback(
2282       __func__, kodiInstance,
2283       [&](CPVRClient* client)
2284       {
2285         if (!handle || !channel)
2286         {
2287           CLog::LogF(LOGERROR, "Invalid callback parameter(s)");
2288           return;
2289         }
2290
2291         auto* channels =
2292             static_cast<std::vector<std::shared_ptr<CPVRChannel>>*>(handle->dataAddress);
2293         channels->emplace_back(std::make_shared<CPVRChannel>(*channel, client->GetID()));
2294       });
2295 }
2296
2297 void CPVRClient::cb_transfer_recording_entry(void* kodiInstance,
2298                                              const PVR_HANDLE handle,
2299                                              const PVR_RECORDING* recording)
2300 {
2301   HandleAddonCallback(__func__, kodiInstance,
2302                       [&](CPVRClient* client)
2303                       {
2304                         if (!handle || !recording)
2305                         {
2306                           CLog::LogF(LOGERROR, "Invalid callback parameter(s)");
2307                           return;
2308                         }
2309
2310                         // transfer this entry to the recordings container
2311                         const std::shared_ptr<CPVRRecording> transferRecording =
2312                             std::make_shared<CPVRRecording>(*recording, client->GetID());
2313                         CPVRRecordings* recordings =
2314                             static_cast<CPVRRecordings*>(handle->dataAddress);
2315                         recordings->UpdateFromClient(transferRecording, *client);
2316                       });
2317 }
2318
2319 void CPVRClient::cb_transfer_timer_entry(void* kodiInstance,
2320                                          const PVR_HANDLE handle,
2321                                          const PVR_TIMER* timer)
2322 {
2323   HandleAddonCallback(__func__, kodiInstance,
2324                       [&](CPVRClient* client)
2325                       {
2326                         if (!handle || !timer)
2327                         {
2328                           CLog::LogF(LOGERROR, "Invalid callback parameter(s)");
2329                           return;
2330                         }
2331
2332                         // Note: channel can be nullptr here, for instance for epg-based timer rules
2333                         //       ("record on any channel" condition)
2334                         const std::shared_ptr<CPVRChannel> channel =
2335                             CServiceBroker::GetPVRManager().ChannelGroups()->GetByUniqueID(
2336                                 timer->iClientChannelUid, client->GetID());
2337
2338                         // transfer this entry to the timers container
2339                         const std::shared_ptr<CPVRTimerInfoTag> transferTimer =
2340                             std::make_shared<CPVRTimerInfoTag>(*timer, channel, client->GetID());
2341                         CPVRTimersContainer* timers =
2342                             static_cast<CPVRTimersContainer*>(handle->dataAddress);
2343                         timers->UpdateFromClient(transferTimer);
2344                       });
2345 }
2346
2347 void CPVRClient::cb_add_menu_hook(void* kodiInstance, const PVR_MENUHOOK* hook)
2348 {
2349   HandleAddonCallback(__func__, kodiInstance,
2350                       [&](CPVRClient* client)
2351                       {
2352                         if (!hook)
2353                         {
2354                           CLog::LogF(LOGERROR, "Invalid callback parameter(s)");
2355                           return;
2356                         }
2357
2358                         client->GetMenuHooks()->AddHook(*hook);
2359                       });
2360 }
2361
2362 void CPVRClient::cb_recording_notification(void* kodiInstance,
2363                                            const char* strName,
2364                                            const char* strFileName,
2365                                            bool bOnOff)
2366 {
2367   HandleAddonCallback(
2368       __func__, kodiInstance,
2369       [&](CPVRClient* client)
2370       {
2371         if (!strFileName)
2372         {
2373           CLog::LogF(LOGERROR, "Invalid callback parameter(s)");
2374           return;
2375         }
2376
2377         const std::string strLine1 = StringUtils::Format(
2378             g_localizeStrings.Get(bOnOff ? 19197 : 19198), client->GetFullClientName());
2379         std::string strLine2;
2380         if (strName)
2381           strLine2 = strName;
2382         else
2383           strLine2 = strFileName;
2384
2385         // display a notification for 5 seconds
2386         CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, strLine1, strLine2, 5000,
2387                                               false);
2388         auto eventLog = CServiceBroker::GetEventLog();
2389         if (eventLog)
2390           eventLog->Add(EventPtr(new CNotificationEvent(client->GetFullClientName(), strLine1,
2391                                                         client->Icon(), strLine2)));
2392
2393         CLog::LogFC(LOGDEBUG, LOGPVR, "Recording {} on client {}. name='{}' filename='{}'",
2394                     bOnOff ? "started" : "finished", client->GetID(), strName, strFileName);
2395       });
2396 }
2397
2398 void CPVRClient::cb_trigger_channel_update(void* kodiInstance)
2399 {
2400   HandleAddonCallback(__func__, kodiInstance,
2401                       [&](CPVRClient* client)
2402                       {
2403                         // update channels in the next iteration of the pvrmanager's main loop
2404                         CServiceBroker::GetPVRManager().TriggerChannelsUpdate(client->GetID());
2405                       });
2406 }
2407
2408 void CPVRClient::cb_trigger_provider_update(void* kodiInstance)
2409 {
2410   HandleAddonCallback(__func__, kodiInstance,
2411                       [&](CPVRClient* client)
2412                       {
2413                         /* update the providers table in the next iteration of the pvrmanager's main loop */
2414                         CServiceBroker::GetPVRManager().TriggerProvidersUpdate(client->GetID());
2415                       });
2416 }
2417
2418 void CPVRClient::cb_trigger_timer_update(void* kodiInstance)
2419 {
2420   HandleAddonCallback(__func__, kodiInstance,
2421                       [&](CPVRClient* client)
2422                       {
2423                         // update timers in the next iteration of the pvrmanager's main loop
2424                         CServiceBroker::GetPVRManager().TriggerTimersUpdate(client->GetID());
2425                       });
2426 }
2427
2428 void CPVRClient::cb_trigger_recording_update(void* kodiInstance)
2429 {
2430   HandleAddonCallback(__func__, kodiInstance,
2431                       [&](CPVRClient* client)
2432                       {
2433                         // update recordings in the next iteration of the pvrmanager's main loop
2434                         CServiceBroker::GetPVRManager().TriggerRecordingsUpdate(client->GetID());
2435                       });
2436 }
2437
2438 void CPVRClient::cb_trigger_channel_groups_update(void* kodiInstance)
2439 {
2440   HandleAddonCallback(__func__, kodiInstance,
2441                       [&](CPVRClient* client)
2442                       {
2443                         // update all channel groups in the next iteration of the pvrmanager's main loop
2444                         CServiceBroker::GetPVRManager().TriggerChannelGroupsUpdate(client->GetID());
2445                       });
2446 }
2447
2448 void CPVRClient::cb_trigger_epg_update(void* kodiInstance, unsigned int iChannelUid)
2449 {
2450   HandleAddonCallback(__func__, kodiInstance,
2451                       [&](CPVRClient* client) {
2452                         CServiceBroker::GetPVRManager().EpgContainer().UpdateRequest(
2453                             client->GetID(), iChannelUid);
2454                       });
2455 }
2456
2457 void CPVRClient::cb_free_demux_packet(void* kodiInstance, DEMUX_PACKET* pPacket)
2458 {
2459   HandleAddonCallback(
2460       __func__, kodiInstance,
2461       [&](CPVRClient* client)
2462       { CDVDDemuxUtils::FreeDemuxPacket(static_cast<DemuxPacket*>(pPacket)); },
2463       true);
2464 }
2465
2466 DEMUX_PACKET* CPVRClient::cb_allocate_demux_packet(void* kodiInstance, int iDataSize)
2467 {
2468   DEMUX_PACKET* result = nullptr;
2469
2470   HandleAddonCallback(
2471       __func__, kodiInstance,
2472       [&](CPVRClient* client) { result = CDVDDemuxUtils::AllocateDemuxPacket(iDataSize); }, true);
2473
2474   return result;
2475 }
2476
2477 void CPVRClient::cb_connection_state_change(void* kodiInstance,
2478                                             const char* strConnectionString,
2479                                             PVR_CONNECTION_STATE newState,
2480                                             const char* strMessage)
2481 {
2482   HandleAddonCallback(__func__, kodiInstance,
2483                       [&](CPVRClient* client)
2484                       {
2485                         if (!strConnectionString)
2486                         {
2487                           CLog::LogF(LOGERROR, "Invalid callback parameter(s)");
2488                           return;
2489                         }
2490
2491                         const PVR_CONNECTION_STATE prevState(client->GetConnectionState());
2492                         if (prevState == newState)
2493                           return;
2494
2495                         CLog::LogFC(LOGDEBUG, LOGPVR,
2496                                     "Connection state for client {} changed from {} to {}",
2497                                     client->GetID(), prevState, newState);
2498
2499                         client->SetConnectionState(newState);
2500
2501                         std::string msg;
2502                         if (strMessage)
2503                           msg = strMessage;
2504
2505                         CServiceBroker::GetPVRManager().ConnectionStateChange(
2506                             client, std::string(strConnectionString), newState, msg);
2507                       });
2508 }
2509
2510 void CPVRClient::cb_epg_event_state_change(void* kodiInstance,
2511                                            EPG_TAG* tag,
2512                                            EPG_EVENT_STATE newState)
2513 {
2514   HandleAddonCallback(__func__, kodiInstance,
2515                       [&](CPVRClient* client)
2516                       {
2517                         if (!tag)
2518                         {
2519                           CLog::LogF(LOGERROR, "Invalid callback parameter(s)");
2520                           return;
2521                         }
2522
2523                         // Note: channel data and epg id may not yet be available. Tag will be fully initialized later.
2524                         const std::shared_ptr<CPVREpgInfoTag> epgTag =
2525                             std::make_shared<CPVREpgInfoTag>(*tag, client->GetID(), nullptr, -1);
2526                         CServiceBroker::GetPVRManager().EpgContainer().UpdateFromClient(epgTag,
2527                                                                                         newState);
2528                       });
2529 }
2530
2531 class CCodecIds
2532 {
2533 public:
2534   virtual ~CCodecIds() = default;
2535
2536   static CCodecIds& GetInstance()
2537   {
2538     static CCodecIds _instance;
2539     return _instance;
2540   }
2541
2542   PVR_CODEC GetCodecByName(const char* strCodecName)
2543   {
2544     PVR_CODEC retVal = PVR_INVALID_CODEC;
2545     if (strlen(strCodecName) == 0)
2546       return retVal;
2547
2548     std::string strUpperCodecName = strCodecName;
2549     StringUtils::ToUpper(strUpperCodecName);
2550
2551     std::map<std::string, PVR_CODEC>::const_iterator it = m_lookup.find(strUpperCodecName);
2552     if (it != m_lookup.end())
2553       retVal = it->second;
2554
2555     return retVal;
2556   }
2557
2558 private:
2559   CCodecIds()
2560   {
2561     // get ids and names
2562     const AVCodec* codec = nullptr;
2563     void* i = nullptr;
2564     PVR_CODEC tmp;
2565     while ((codec = av_codec_iterate(&i)))
2566     {
2567       if (av_codec_is_decoder(codec))
2568       {
2569         tmp.codec_type = static_cast<PVR_CODEC_TYPE>(codec->type);
2570         tmp.codec_id = codec->id;
2571
2572         std::string strUpperCodecName = codec->name;
2573         StringUtils::ToUpper(strUpperCodecName);
2574
2575         m_lookup.insert(std::make_pair(strUpperCodecName, tmp));
2576       }
2577     }
2578
2579     // teletext is not returned by av_codec_next. we got our own decoder
2580     tmp.codec_type = PVR_CODEC_TYPE_SUBTITLE;
2581     tmp.codec_id = AV_CODEC_ID_DVB_TELETEXT;
2582     m_lookup.insert(std::make_pair("TELETEXT", tmp));
2583
2584     // rds is not returned by av_codec_next. we got our own decoder
2585     tmp.codec_type = PVR_CODEC_TYPE_RDS;
2586     tmp.codec_id = AV_CODEC_ID_NONE;
2587     m_lookup.insert(std::make_pair("RDS", tmp));
2588
2589     // ID3 is not returned by av_codec_next. we got our own decoder
2590     tmp.codec_type = PVR_CODEC_TYPE_ID3;
2591     tmp.codec_id = AV_CODEC_ID_NONE;
2592     m_lookup.insert({"ID3", tmp});
2593   }
2594
2595   std::map<std::string, PVR_CODEC> m_lookup;
2596 };
2597
2598 PVR_CODEC CPVRClient::cb_get_codec_by_name(const void* kodiInstance, const char* strCodecName)
2599 {
2600   PVR_CODEC result = PVR_INVALID_CODEC;
2601
2602   HandleAddonCallback(
2603       __func__, const_cast<void*>(kodiInstance),
2604       [&](CPVRClient* client) { result = CCodecIds::GetInstance().GetCodecByName(strCodecName); },
2605       true);
2606
2607   return result;
2608 }
2609
2610 } // namespace PVR