xbmc/pvr/guilib/PVRGUIChannelNavigator.cpp

   1 /*
   2  *  Copyright (C) 2017-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 "PVRGUIChannelNavigator.h"
  10
  11 #include "FileItem.h"
  12 #include "GUIInfoManager.h"
  13 #include "ServiceBroker.h"
  14 #include "guilib/GUIComponent.h"
  15 #include "pvr/PVRManager.h"
  16 #include "pvr/PVRPlaybackState.h"
  17 #include "pvr/channels/PVRChannelGroup.h"
  18 #include "pvr/guilib/PVRGUIActionsPlayback.h"
  19 #include "settings/Settings.h"
  20 #include "settings/SettingsComponent.h"
  21 #include "threads/SystemClock.h"
  22 #include "utils/Job.h"
  23 #include "utils/JobManager.h"
  24 #include "utils/XTimeUtils.h"
  25
  26 #include <memory>
  27 #include <mutex>
  28
  29 using namespace KODI::GUILIB::GUIINFO;
  30 using namespace PVR;
  31 using namespace std::chrono_literals;
  32
  33 namespace
  34 {
  35 class CPVRChannelTimeoutJobBase : public CJob, public IJobCallback
  36 {
  37 public:
  38   CPVRChannelTimeoutJobBase() = delete;
  39   CPVRChannelTimeoutJobBase(PVR::CPVRGUIChannelNavigator& channelNavigator,
  40                             std::chrono::milliseconds timeout)
  41     : m_channelNavigator(channelNavigator)
  42   {
  43     m_delayTimer.Set(timeout);
  44   }
  45
  46   ~CPVRChannelTimeoutJobBase() override = default;
  47
  48   virtual void OnTimeout() = 0;
  49
  50   void OnJobComplete(unsigned int iJobID, bool bSuccess, CJob* job) override {}
  51
  52   bool DoWork() override
  53   {
  54     while (!ShouldCancel(0, 0))
  55     {
  56       if (m_delayTimer.IsTimePast())
  57       {
  58         OnTimeout();
  59         return true;
  60       }
  61       KODI::TIME::Sleep(10ms);
  62     }
  63     return false;
  64   }
  65
  66 protected:
  67   PVR::CPVRGUIChannelNavigator& m_channelNavigator;
  68
  69 private:
  70   XbmcThreads::EndTime<> m_delayTimer;
  71 };
  72
  73 class CPVRChannelEntryTimeoutJob : public CPVRChannelTimeoutJobBase
  74 {
  75 public:
  76   CPVRChannelEntryTimeoutJob(PVR::CPVRGUIChannelNavigator& channelNavigator,
  77                              std::chrono::milliseconds timeout)
  78     : CPVRChannelTimeoutJobBase(channelNavigator, timeout)
  79   {
  80   }
  81   ~CPVRChannelEntryTimeoutJob() override = default;
  82   const char* GetType() const override { return "pvr-channel-entry-timeout-job"; }
  83   void OnTimeout() override { m_channelNavigator.SwitchToCurrentChannel(); }
  84 };
  85
  86 class CPVRChannelInfoTimeoutJob : public CPVRChannelTimeoutJobBase
  87 {
  88 public:
  89   CPVRChannelInfoTimeoutJob(PVR::CPVRGUIChannelNavigator& channelNavigator,
  90                             std::chrono::milliseconds timeout)
  91     : CPVRChannelTimeoutJobBase(channelNavigator, timeout)
  92   {
  93   }
  94   ~CPVRChannelInfoTimeoutJob() override = default;
  95   const char* GetType() const override { return "pvr-channel-info-timeout-job"; }
  96   void OnTimeout() override { m_channelNavigator.HideInfo(); }
  97 };
  98 } // unnamed namespace
  99
 100 CPVRGUIChannelNavigator::CPVRGUIChannelNavigator()
 101 {
 102   // Note: we cannot subscribe to PlayerInfoProvider here, as we're getting constructed
 103   // before the info providers. We will subscribe once our first subscriber appears.
 104 }
 105
 106 CPVRGUIChannelNavigator::~CPVRGUIChannelNavigator()
 107 {
 108   const auto gui = CServiceBroker::GetGUI();
 109   if (!gui)
 110     return;
 111
 112   gui->GetInfoManager().GetInfoProviders().GetPlayerInfoProvider().Events().Unsubscribe(this);
 113 }
 114
 115 void CPVRGUIChannelNavigator::SubscribeToShowInfoEventStream()
 116 {
 117   CServiceBroker::GetGUI()
 118       ->GetInfoManager()
 119       .GetInfoProviders()
 120       .GetPlayerInfoProvider()
 121       .Events()
 122       .Subscribe(this, &CPVRGUIChannelNavigator::Notify);
 123 }
 124
 125 void CPVRGUIChannelNavigator::CheckAndPublishPreviewAndPlayerShowInfoChangedEvent()
 126 {
 127   std::unique_lock<CCriticalSection> lock(m_critSection);
 128
 129   const bool currentValue = IsPreview() && m_playerShowInfo;
 130   if (m_previewAndPlayerShowInfo != currentValue)
 131   {
 132     m_previewAndPlayerShowInfo = currentValue;
 133
 134     // inform subscribers
 135     m_events.Publish(PVRPreviewAndPlayerShowInfoChangedEvent(currentValue));
 136   }
 137 }
 138
 139 void CPVRGUIChannelNavigator::Notify(const PlayerShowInfoChangedEvent& event)
 140 {
 141   std::unique_lock<CCriticalSection> lock(m_critSection);
 142
 143   m_playerShowInfo = event.m_showInfo;
 144   CheckAndPublishPreviewAndPlayerShowInfoChangedEvent();
 145 }
 146
 147 void CPVRGUIChannelNavigator::SelectNextChannel(ChannelSwitchMode eSwitchMode)
 148 {
 149   std::unique_lock<CCriticalSection> lock(m_critSection);
 150
 151   if (!m_playerShowInfo && eSwitchMode == ChannelSwitchMode::NO_SWITCH)
 152   {
 153     // show info for current channel on first next channel selection.
 154     ShowInfo(false);
 155     return;
 156   }
 157
 158   const std::shared_ptr<CPVRChannelGroupMember> nextMember = GetNextOrPrevChannel(true);
 159   if (nextMember)
 160     SelectChannel(nextMember, eSwitchMode);
 161 }
 162
 163 void CPVRGUIChannelNavigator::SelectPreviousChannel(ChannelSwitchMode eSwitchMode)
 164 {
 165   std::unique_lock<CCriticalSection> lock(m_critSection);
 166
 167   if (!m_playerShowInfo && eSwitchMode == ChannelSwitchMode::NO_SWITCH)
 168   {
 169     // show info for current channel on first previous channel selection.
 170     ShowInfo(false);
 171     return;
 172   }
 173
 174   const std::shared_ptr<CPVRChannelGroupMember> prevMember = GetNextOrPrevChannel(false);
 175   if (prevMember)
 176     SelectChannel(prevMember, eSwitchMode);
 177 }
 178
 179 std::shared_ptr<CPVRChannelGroupMember> CPVRGUIChannelNavigator::GetNextOrPrevChannel(bool bNext)
 180 {
 181   const bool bPlayingRadio = CServiceBroker::GetPVRManager().PlaybackState()->IsPlayingRadio();
 182   const bool bPlayingTV = CServiceBroker::GetPVRManager().PlaybackState()->IsPlayingTV();
 183
 184   if (bPlayingTV || bPlayingRadio)
 185   {
 186     const std::shared_ptr<const CPVRChannelGroup> group =
 187         CServiceBroker::GetPVRManager().PlaybackState()->GetActiveChannelGroup(bPlayingRadio);
 188     if (group)
 189     {
 190       std::unique_lock<CCriticalSection> lock(m_critSection);
 191       return bNext ? group->GetNextChannelGroupMember(m_currentChannel)
 192                    : group->GetPreviousChannelGroupMember(m_currentChannel);
 193     }
 194   }
 195   return {};
 196 }
 197
 198 void CPVRGUIChannelNavigator::SelectChannel(
 199     const std::shared_ptr<CPVRChannelGroupMember>& groupMember, ChannelSwitchMode eSwitchMode)
 200 {
 201   CServiceBroker::GetGUI()->GetInfoManager().SetCurrentItem(CFileItem(groupMember));
 202
 203   std::unique_lock<CCriticalSection> lock(m_critSection);
 204
 205   m_currentChannel = groupMember;
 206   ShowInfo(false);
 207
 208   CheckAndPublishPreviewAndPlayerShowInfoChangedEvent();
 209
 210   if (IsPreview() && eSwitchMode == ChannelSwitchMode::INSTANT_OR_DELAYED_SWITCH)
 211   {
 212     auto timeout =
 213         std::chrono::milliseconds(CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
 214             CSettings::SETTING_PVRPLAYBACK_CHANNELENTRYTIMEOUT));
 215     if (timeout > 0ms)
 216     {
 217       // delayed switch
 218       if (m_iChannelEntryJobId >= 0)
 219         CServiceBroker::GetJobManager()->CancelJob(m_iChannelEntryJobId);
 220
 221       CPVRChannelEntryTimeoutJob* job = new CPVRChannelEntryTimeoutJob(*this, timeout);
 222       m_iChannelEntryJobId =
 223           CServiceBroker::GetJobManager()->AddJob(job, dynamic_cast<IJobCallback*>(job));
 224     }
 225     else
 226     {
 227       // instant switch
 228       SwitchToCurrentChannel();
 229     }
 230   }
 231 }
 232
 233 void CPVRGUIChannelNavigator::SwitchToCurrentChannel()
 234 {
 235   std::unique_ptr<CFileItem> item;
 236
 237   {
 238     std::unique_lock<CCriticalSection> lock(m_critSection);
 239
 240     if (m_iChannelEntryJobId >= 0)
 241     {
 242       CServiceBroker::GetJobManager()->CancelJob(m_iChannelEntryJobId);
 243       m_iChannelEntryJobId = -1;
 244     }
 245
 246     item = std::make_unique<CFileItem>(m_currentChannel);
 247   }
 248
 249   CServiceBroker::GetPVRManager().Get<PVR::GUI::Playback>().SwitchToChannel(*item, false);
 250 }
 251
 252 bool CPVRGUIChannelNavigator::IsPreview() const
 253 {
 254   std::unique_lock<CCriticalSection> lock(m_critSection);
 255   return m_currentChannel != m_playingChannel;
 256 }
 257
 258 bool CPVRGUIChannelNavigator::IsPreviewAndShowInfo() const
 259 {
 260   std::unique_lock<CCriticalSection> lock(m_critSection);
 261   return m_previewAndPlayerShowInfo;
 262 }
 263
 264 void CPVRGUIChannelNavigator::ShowInfo()
 265 {
 266   ShowInfo(true);
 267 }
 268
 269 void CPVRGUIChannelNavigator::ShowInfo(bool bForce)
 270 {
 271   auto timeout = std::chrono::seconds(CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
 272       CSettings::SETTING_PVRMENU_DISPLAYCHANNELINFO));
 273
 274   if (bForce || timeout > 0s)
 275   {
 276     CServiceBroker::GetGUI()
 277         ->GetInfoManager()
 278         .GetInfoProviders()
 279         .GetPlayerInfoProvider()
 280         .SetShowInfo(true);
 281
 282     std::unique_lock<CCriticalSection> lock(m_critSection);
 283
 284     if (m_iChannelInfoJobId >= 0)
 285     {
 286       CServiceBroker::GetJobManager()->CancelJob(m_iChannelInfoJobId);
 287       m_iChannelInfoJobId = -1;
 288     }
 289
 290     if (!bForce && timeout > 0s)
 291     {
 292       CPVRChannelInfoTimeoutJob* job = new CPVRChannelInfoTimeoutJob(*this, timeout);
 293       m_iChannelInfoJobId =
 294           CServiceBroker::GetJobManager()->AddJob(job, dynamic_cast<IJobCallback*>(job));
 295     }
 296   }
 297 }
 298
 299 void CPVRGUIChannelNavigator::HideInfo()
 300 {
 301   CServiceBroker::GetGUI()->GetInfoManager().GetInfoProviders().GetPlayerInfoProvider().SetShowInfo(
 302       false);
 303
 304   CFileItemPtr item;
 305
 306   {
 307     std::unique_lock<CCriticalSection> lock(m_critSection);
 308
 309     if (m_iChannelInfoJobId >= 0)
 310     {
 311       CServiceBroker::GetJobManager()->CancelJob(m_iChannelInfoJobId);
 312       m_iChannelInfoJobId = -1;
 313     }
 314
 315     if (m_currentChannel != m_playingChannel)
 316     {
 317       m_currentChannel = m_playingChannel;
 318       if (m_playingChannel)
 319         item = std::make_shared<CFileItem>(m_playingChannel);
 320     }
 321
 322     CheckAndPublishPreviewAndPlayerShowInfoChangedEvent();
 323   }
 324
 325   if (item)
 326     CServiceBroker::GetGUI()->GetInfoManager().SetCurrentItem(*item);
 327 }
 328
 329 void CPVRGUIChannelNavigator::ToggleInfo()
 330 {
 331   std::unique_lock<CCriticalSection> lock(m_critSection);
 332
 333   if (m_playerShowInfo)
 334     HideInfo();
 335   else
 336     ShowInfo();
 337 }
 338
 339 void CPVRGUIChannelNavigator::SetPlayingChannel(
 340     const std::shared_ptr<CPVRChannelGroupMember>& groupMember)
 341 {
 342   CFileItemPtr item;
 343
 344   if (groupMember)
 345   {
 346     std::unique_lock<CCriticalSection> lock(m_critSection);
 347
 348     m_playingChannel = groupMember;
 349     if (m_currentChannel != m_playingChannel)
 350     {
 351       m_currentChannel = m_playingChannel;
 352       if (m_playingChannel)
 353         item = std::make_shared<CFileItem>(m_playingChannel);
 354     }
 355
 356     CheckAndPublishPreviewAndPlayerShowInfoChangedEvent();
 357   }
 358
 359   if (item)
 360     CServiceBroker::GetGUI()->GetInfoManager().SetCurrentItem(*item);
 361
 362   ShowInfo(false);
 363 }
 364
 365 void CPVRGUIChannelNavigator::ClearPlayingChannel()
 366 {
 367   std::unique_lock<CCriticalSection> lock(m_critSection);
 368
 369   m_playingChannel.reset();
 370   HideInfo();
 371
 372   CheckAndPublishPreviewAndPlayerShowInfoChangedEvent();
 373 }