xbmc/pvr/windows/GUIWindowPVRGuide.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 "GUIWindowPVRGuide.h"
  10
  11 #include "FileItem.h"
  12 #include "FileItemList.h"
  13 #include "GUIUserMessages.h"
  14 #include "ServiceBroker.h"
  15 #include "addons/Skin.h"
  16 #include "dialogs/GUIDialogBusy.h"
  17 #include "dialogs/GUIDialogContextMenu.h"
  18 #include "dialogs/GUIDialogNumeric.h"
  19 #include "guilib/GUIMessage.h"
  20 #include "guilib/GUIWindowManager.h"
  21 #include "guilib/LocalizeStrings.h"
  22 #include "input/actions/Action.h"
  23 #include "input/actions/ActionIDs.h"
  24 #include "messaging/ApplicationMessenger.h"
  25 #include "messaging/helpers/DialogHelper.h"
  26 #include "pvr/PVRItem.h"
  27 #include "pvr/PVRManager.h"
  28 #include "pvr/PVRPlaybackState.h"
  29 #include "pvr/channels/PVRChannel.h"
  30 #include "pvr/channels/PVRChannelGroup.h"
  31 #include "pvr/channels/PVRChannelGroupMember.h"
  32 #include "pvr/channels/PVRChannelGroupsContainer.h"
  33 #include "pvr/channels/PVRChannelsPath.h"
  34 #include "pvr/epg/EpgChannelData.h"
  35 #include "pvr/epg/EpgContainer.h"
  36 #include "pvr/epg/EpgInfoTag.h"
  37 #include "pvr/guilib/GUIEPGGridContainer.h"
  38 #include "pvr/guilib/PVRGUIActionsChannels.h"
  39 #include "pvr/guilib/PVRGUIActionsEPG.h"
  40 #include "pvr/guilib/PVRGUIActionsPlayback.h"
  41 #include "pvr/guilib/PVRGUIActionsTimers.h"
  42 #include "pvr/recordings/PVRRecordings.h"
  43 #include "pvr/timers/PVRTimers.h"
  44 #include "settings/Settings.h"
  45 #include "settings/SettingsComponent.h"
  46 #include "video/guilib/VideoPlayActionProcessor.h"
  47 #include "view/GUIViewState.h"
  48
  49 #include <functional>
  50 #include <memory>
  51 #include <mutex>
  52 #include <utility>
  53 #include <vector>
  54
  55 using namespace KODI::MESSAGING;
  56 using namespace PVR;
  57 using namespace std::chrono_literals;
  58
  59 CGUIWindowPVRGuideBase::CGUIWindowPVRGuideBase(bool bRadio, int id, const std::string& xmlFile)
  60   : CGUIWindowPVRBase(bRadio, id, xmlFile)
  61 {
  62   CServiceBroker::GetPVRManager().Get<PVR::GUI::Channels>().RegisterChannelNumberInputHandler(this);
  63 }
  64
  65 CGUIWindowPVRGuideBase::~CGUIWindowPVRGuideBase()
  66 {
  67   CServiceBroker::GetPVRManager().Get<PVR::GUI::Channels>().DeregisterChannelNumberInputHandler(
  68       this);
  69
  70   m_bRefreshTimelineItems = false;
  71   m_bSyncRefreshTimelineItems = false;
  72   StopRefreshTimelineItemsThread();
  73 }
  74
  75 CGUIEPGGridContainer* CGUIWindowPVRGuideBase::GetGridControl()
  76 {
  77   return dynamic_cast<CGUIEPGGridContainer*>(GetControl(m_viewControl.GetCurrentControl()));
  78 }
  79
  80 void CGUIWindowPVRGuideBase::InitEpgGridControl()
  81 {
  82   CGUIEPGGridContainer* epgGridContainer = GetGridControl();
  83   if (epgGridContainer)
  84   {
  85     CPVRManager& mgr = CServiceBroker::GetPVRManager();
  86
  87     const std::shared_ptr<CPVRChannel> channel = mgr.ChannelGroups()->GetByPath(
  88         mgr.Get<PVR::GUI::Channels>().GetSelectedChannelPath(m_bRadio));
  89
  90     if (channel)
  91     {
  92       m_bChannelSelectionRestored = epgGridContainer->SetChannel(channel);
  93       epgGridContainer->JumpToDate(
  94           mgr.PlaybackState()->GetPlaybackTime(channel->ClientID(), channel->UniqueID()));
  95     }
  96     else
  97     {
  98       m_bChannelSelectionRestored = false;
  99       epgGridContainer->JumpToNow();
 100     }
 101
 102     if (!epgGridContainer->HasData())
 103       m_bSyncRefreshTimelineItems = true; // force data update on first window open
 104   }
 105
 106   StartRefreshTimelineItemsThread();
 107 }
 108
 109 void CGUIWindowPVRGuideBase::ClearData()
 110 {
 111   {
 112     std::unique_lock<CCriticalSection> lock(m_critSection);
 113     m_cachedChannelGroup.reset();
 114   }
 115
 116   CGUIWindowPVRBase::ClearData();
 117 }
 118
 119 void CGUIWindowPVRGuideBase::OnInitWindow()
 120 {
 121   if (m_guiState)
 122     m_viewControl.SetCurrentView(m_guiState->GetViewAsControl(), false);
 123
 124   if (InitChannelGroup()) // no channels -> lazy init
 125     InitEpgGridControl();
 126
 127   CGUIWindowPVRBase::OnInitWindow();
 128 }
 129
 130 void CGUIWindowPVRGuideBase::OnDeinitWindow(int nextWindowID)
 131 {
 132   StopRefreshTimelineItemsThread();
 133
 134   m_bChannelSelectionRestored = false;
 135
 136   CGUIDialog* dialog =
 137       CServiceBroker::GetGUI()->GetWindowManager().GetDialog(WINDOW_DIALOG_PVR_GUIDE_CONTROLS);
 138   if (dialog && dialog->IsDialogRunning())
 139   {
 140     dialog->Close();
 141   }
 142
 143   CGUIWindowPVRBase::OnDeinitWindow(nextWindowID);
 144 }
 145
 146 void CGUIWindowPVRGuideBase::StartRefreshTimelineItemsThread()
 147 {
 148   StopRefreshTimelineItemsThread();
 149   m_refreshTimelineItemsThread = std::make_unique<CPVRRefreshTimelineItemsThread>(this);
 150   m_refreshTimelineItemsThread->Create();
 151 }
 152
 153 void CGUIWindowPVRGuideBase::StopRefreshTimelineItemsThread()
 154 {
 155   if (m_refreshTimelineItemsThread)
 156     m_refreshTimelineItemsThread->Stop();
 157 }
 158
 159 void CGUIWindowPVRGuideBase::NotifyEvent(const PVREvent& event)
 160 {
 161   if (event == PVREvent::Epg || event == PVREvent::EpgContainer ||
 162       event == PVREvent::ChannelGroupInvalidated || event == PVREvent::ChannelGroup)
 163   {
 164     m_bRefreshTimelineItems = true;
 165     // no base class call => do async refresh
 166     return;
 167   }
 168   else if (event == PVREvent::ChannelPlaybackStopped)
 169   {
 170     if (m_guiState && m_guiState->GetSortMethod().sortBy == SortByLastPlayed)
 171     {
 172       // set dirty to force sync refresh
 173       m_bSyncRefreshTimelineItems = true;
 174     }
 175   }
 176
 177   // do sync refresh if dirty
 178   CGUIWindowPVRBase::NotifyEvent(event);
 179 }
 180
 181 void CGUIWindowPVRGuideBase::SetInvalid()
 182 {
 183   CGUIEPGGridContainer* epgGridContainer = GetGridControl();
 184   if (epgGridContainer)
 185     epgGridContainer->SetInvalid();
 186
 187   CGUIWindowPVRBase::SetInvalid();
 188 }
 189
 190 void CGUIWindowPVRGuideBase::GetContextButtons(int itemNumber, CContextButtons& buttons)
 191 {
 192   CGUIWindowPVRBase::GetContextButtons(itemNumber, buttons);
 193
 194   buttons.Add(CONTEXT_BUTTON_NAVIGATE, 19326); // Navigate...
 195 }
 196
 197 void CGUIWindowPVRGuideBase::UpdateSelectedItemPath()
 198 {
 199   CGUIEPGGridContainer* epgGridContainer = GetGridControl();
 200   if (epgGridContainer)
 201   {
 202     const std::shared_ptr<const CPVRChannelGroupMember> groupMember =
 203         epgGridContainer->GetSelectedChannelGroupMember();
 204     if (groupMember)
 205       CServiceBroker::GetPVRManager().Get<PVR::GUI::Channels>().SetSelectedChannelPath(
 206           m_bRadio, groupMember->Path());
 207   }
 208 }
 209
 210 void CGUIWindowPVRGuideBase::UpdateButtons()
 211 {
 212   CGUIWindowPVRBase::UpdateButtons();
 213
 214   SET_CONTROL_LABEL(CONTROL_LABEL_HEADER1, g_localizeStrings.Get(19032));
 215
 216   const std::shared_ptr<const CPVRChannelGroup> group = GetChannelGroup();
 217   SET_CONTROL_LABEL(CONTROL_LABEL_HEADER2, group ? group->GroupName() : "");
 218 }
 219
 220 bool CGUIWindowPVRGuideBase::Update(const std::string& strDirectory,
 221                                     bool updateFilterPath /* = true */)
 222 {
 223   if (m_bUpdating)
 224   {
 225     // Prevent concurrent updates. Instead, let the timeline items refresh thread pick it up later.
 226     m_bRefreshTimelineItems = true;
 227     return true;
 228   }
 229
 230   bool bReturn = CGUIWindowPVRBase::Update(strDirectory, updateFilterPath);
 231
 232   if (bReturn && !m_bChannelSelectionRestored)
 233   {
 234     CGUIEPGGridContainer* epgGridContainer = GetGridControl();
 235     if (epgGridContainer)
 236       m_bChannelSelectionRestored = epgGridContainer->SetChannel(
 237           CServiceBroker::GetPVRManager().Get<PVR::GUI::Channels>().GetSelectedChannelPath(
 238               m_bRadio));
 239   }
 240
 241   return bReturn;
 242 }
 243
 244 bool CGUIWindowPVRGuideBase::GetDirectory(const std::string& strDirectory, CFileItemList& items)
 245 {
 246   {
 247     std::unique_lock<CCriticalSection> lock(m_critSection);
 248
 249     if (m_cachedChannelGroup && *m_cachedChannelGroup != *GetChannelGroup())
 250     {
 251       // channel group change and not very first open of this window. force immediate update.
 252       m_bSyncRefreshTimelineItems = true;
 253     }
 254   }
 255
 256   if (m_bSyncRefreshTimelineItems)
 257     m_refreshTimelineItemsThread->DoRefresh(true);
 258
 259   const CGUIEPGGridContainer* epgGridContainer = GetGridControl();
 260   if (epgGridContainer)
 261   {
 262     const std::unique_ptr<CFileItemList> newTimeline = GetGridControl()->GetCurrentTimeLineItems();
 263     items.RemoveDiscCache(GetID());
 264     items.Assign(*newTimeline, false);
 265   }
 266
 267   return true;
 268 }
 269
 270 void CGUIWindowPVRGuideBase::FormatAndSort(CFileItemList& items)
 271 {
 272   // Speedup: Nothing to do here as sorting was already done in RefreshTimelineItems
 273   return;
 274 }
 275
 276 CFileItemPtr CGUIWindowPVRGuideBase::GetCurrentListItem(int offset /*= 0*/)
 277 {
 278   const CGUIEPGGridContainer* epgGridContainer = GetGridControl();
 279   if (epgGridContainer)
 280     return epgGridContainer->GetSelectedGridItem(offset);
 281
 282   return {};
 283 }
 284
 285 int CGUIWindowPVRGuideBase::GetCurrentListItemIndex(const std::shared_ptr<const CFileItem>& item)
 286 {
 287   return item ? item->GetProperty("TimelineIndex").asInteger32() : -1;
 288 }
 289
 290 bool CGUIWindowPVRGuideBase::ShouldNavigateToGridContainer(int iAction)
 291 {
 292   CGUIEPGGridContainer* epgGridContainer = GetGridControl();
 293   CGUIControl* control = GetControl(CONTROL_LSTCHANNELGROUPS);
 294   if (epgGridContainer && control && GetFocusedControlID() == control->GetID())
 295   {
 296     int iNavigationId = control->GetAction(iAction).GetNavigation();
 297     if (iNavigationId > 0)
 298     {
 299       control = epgGridContainer;
 300       while (control !=
 301              this) // navigation target could be the grid control or one of its parent controls.
 302       {
 303         if (iNavigationId == control->GetID())
 304         {
 305           // channel group selector control's target for the action is the grid control
 306           return true;
 307         }
 308         control = control->GetParentControl();
 309       }
 310     }
 311   }
 312   return false;
 313 }
 314
 315 bool CGUIWindowPVRGuideBase::OnAction(const CAction& action)
 316 {
 317   switch (action.GetID())
 318   {
 319     case ACTION_MOVE_UP:
 320     case ACTION_MOVE_DOWN:
 321     case ACTION_MOVE_LEFT:
 322     case ACTION_MOVE_RIGHT:
 323     {
 324       // Check whether grid container is configured as channel group selector's navigation target for the given action.
 325       if (ShouldNavigateToGridContainer(action.GetID()))
 326       {
 327         CGUIEPGGridContainer* epgGridContainer = GetGridControl();
 328         if (epgGridContainer)
 329         {
 330           CGUIWindowPVRBase::OnAction(action);
 331
 332           switch (action.GetID())
 333           {
 334             case ACTION_MOVE_UP:
 335               epgGridContainer->GoToBottom();
 336               return true;
 337             case ACTION_MOVE_DOWN:
 338               epgGridContainer->GoToTop();
 339               return true;
 340             case ACTION_MOVE_LEFT:
 341               epgGridContainer->GoToMostRight();
 342               return true;
 343             case ACTION_MOVE_RIGHT:
 344               epgGridContainer->GoToMostLeft();
 345               return true;
 346             default:
 347               break;
 348           }
 349         }
 350       }
 351       break;
 352     }
 353     case REMOTE_0:
 354       if (GetCurrentDigitCount() == 0)
 355       {
 356         // single zero input is handled by epg grid container
 357         break;
 358       }
 359       // fall-thru is intended
 360       [[fallthrough]];
 361     case REMOTE_1:
 362     case REMOTE_2:
 363     case REMOTE_3:
 364     case REMOTE_4:
 365     case REMOTE_5:
 366     case REMOTE_6:
 367     case REMOTE_7:
 368     case REMOTE_8:
 369     case REMOTE_9:
 370       AppendChannelNumberCharacter(static_cast<char>(action.GetID() - REMOTE_0) + '0');
 371       return true;
 372
 373     case ACTION_CHANNEL_NUMBER_SEP:
 374       AppendChannelNumberCharacter(CPVRChannelNumber::SEPARATOR);
 375       return true;
 376   }
 377
 378   return CGUIWindowPVRBase::OnAction(action);
 379 }
 380
 381 void CGUIWindowPVRGuideBase::RefreshView(CGUIMessage& message, bool bInitGridControl)
 382 {
 383   CGUIWindowPVRBase::OnMessage(message);
 384
 385   // force grid data update
 386   m_bSyncRefreshTimelineItems = true;
 387
 388   if (bInitGridControl)
 389     InitEpgGridControl();
 390
 391   Refresh(true);
 392 }
 393
 394 bool CGUIWindowPVRGuideBase::OnMessage(CGUIMessage& message)
 395 {
 396   bool bReturn = false;
 397   switch (message.GetMessage())
 398   {
 399     case GUI_MSG_WINDOW_INIT:
 400     {
 401       const CPVRChannelsPath path(message.GetStringParam(0));
 402       if (path.IsValid() && path.IsChannelGroup())
 403       {
 404         // if a path to a channel group is given we must init
 405         // that group instead of last played/selected group
 406         SetChannelGroupPath(message.GetStringParam(0));
 407       }
 408       break;
 409     }
 410
 411     case GUI_MSG_ITEM_SELECTED:
 412       message.SetParam1(GetCurrentListItemIndex(GetCurrentListItem()));
 413       bReturn = true;
 414       break;
 415
 416     case GUI_MSG_CLICKED:
 417     {
 418       if (message.GetSenderId() == m_viewControl.GetCurrentControl())
 419       {
 420         if (message.GetParam1() == ACTION_SELECT_ITEM ||
 421             message.GetParam1() == ACTION_MOUSE_LEFT_CLICK)
 422         {
 423           // If direct channel number input is active, select the entered channel.
 424           if (CServiceBroker::GetPVRManager()
 425                   .Get<PVR::GUI::Channels>()
 426                   .GetChannelNumberInputHandler()
 427                   .CheckInputAndExecuteAction())
 428           {
 429             bReturn = true;
 430             break;
 431           }
 432         }
 433
 434         const std::shared_ptr<CFileItem> pItem = GetCurrentListItem();
 435         if (pItem)
 436         {
 437           switch (message.GetParam1())
 438           {
 439             case ACTION_SELECT_ITEM:
 440             case ACTION_MOUSE_LEFT_CLICK:
 441               switch (CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
 442                   CSettings::SETTING_EPG_SELECTACTION))
 443               {
 444                 case EPG_SELECT_ACTION_CONTEXT_MENU:
 445                   OnPopupMenu(GetCurrentListItemIndex(pItem));
 446                   bReturn = true;
 447                   break;
 448                 case EPG_SELECT_ACTION_SWITCH:
 449                   CServiceBroker::GetPVRManager().Get<PVR::GUI::Playback>().SwitchToChannel(*pItem);
 450                   bReturn = true;
 451                   break;
 452                 case EPG_SELECT_ACTION_PLAY_RECORDING:
 453                 {
 454                   const std::shared_ptr<CPVRRecording> recording{CPVRItem(pItem).GetRecording()};
 455                   if (recording)
 456                   {
 457                     KODI::VIDEO::GUILIB::CVideoPlayActionProcessor proc{
 458                         std::make_shared<CFileItem>(recording)};
 459                     proc.ProcessDefaultAction();
 460                     bReturn = true;
 461                   }
 462                   break;
 463                 }
 464                 case EPG_SELECT_ACTION_INFO:
 465                   CServiceBroker::GetPVRManager().Get<PVR::GUI::EPG>().ShowEPGInfo(*pItem);
 466                   bReturn = true;
 467                   break;
 468                 case EPG_SELECT_ACTION_RECORD:
 469                   CServiceBroker::GetPVRManager().Get<PVR::GUI::Timers>().ToggleTimer(*pItem);
 470                   bReturn = true;
 471                   break;
 472                 case EPG_SELECT_ACTION_SMART_SELECT:
 473                 {
 474                   const std::shared_ptr<const CPVREpgInfoTag> tag(pItem->GetEPGInfoTag());
 475                   if (tag)
 476                   {
 477                     const CDateTime start(tag->StartAsUTC());
 478                     const CDateTime end(tag->EndAsUTC());
 479                     const CDateTime now(CDateTime::GetUTCDateTime());
 480
 481                     if (start <= now && now <= end)
 482                     {
 483                       // current event
 484                       CServiceBroker::GetPVRManager().Get<PVR::GUI::Playback>().SwitchToChannel(
 485                           *pItem);
 486                     }
 487                     else if (now < start)
 488                     {
 489                       // future event
 490                       if (CServiceBroker::GetPVRManager().Timers()->GetTimerForEpgTag(tag))
 491                         CServiceBroker::GetPVRManager().Get<PVR::GUI::Timers>().EditTimer(*pItem);
 492                       else
 493                       {
 494                         bool bCanRecord = true;
 495                         const std::shared_ptr<const CPVRChannel> channel =
 496                             CPVRItem(pItem).GetChannel();
 497                         if (channel)
 498                           bCanRecord = channel->CanRecord();
 499
 500                         const int iTextID =
 501                             bCanRecord
 502                                 ? 19302 // "Do you want to record the selected programme or to switch to the current programme?"
 503                                 : 19344; // "Do you want to set a reminder for the selected programme or to switch to the current programme?"
 504                         const int iNoButtonID = bCanRecord ? 264 // No => "Record"
 505                                                            : 826; // "Set reminder"
 506
 507                         HELPERS::DialogResponse ret =
 508                             HELPERS::ShowYesNoDialogText(CVariant{19096}, // "Smart select"
 509                                                          CVariant{iTextID}, CVariant{iNoButtonID},
 510                                                          CVariant{19165}); // Yes => "Switch"
 511                         if (ret == HELPERS::DialogResponse::CHOICE_NO)
 512                           CServiceBroker::GetPVRManager().Get<PVR::GUI::Timers>().AddTimer(*pItem,
 513                                                                                            false);
 514                         else if (ret == HELPERS::DialogResponse::CHOICE_YES)
 515                           CServiceBroker::GetPVRManager().Get<PVR::GUI::Playback>().SwitchToChannel(
 516                               *pItem);
 517                       }
 518                     }
 519                     else
 520                     {
 521                       // past event
 522                       const std::shared_ptr<CPVRRecording> recording{
 523                           CPVRItem(pItem).GetRecording()};
 524                       if (recording)
 525                       {
 526                         KODI::VIDEO::GUILIB::CVideoPlayActionProcessor proc{
 527                             std::make_shared<CFileItem>(recording)};
 528                         proc.ProcessDefaultAction();
 529                       }
 530                       else if (tag->IsPlayable())
 531                         CServiceBroker::GetPVRManager().Get<PVR::GUI::Playback>().PlayEpgTag(
 532                             *pItem);
 533                       else
 534                         CServiceBroker::GetPVRManager().Get<PVR::GUI::EPG>().ShowEPGInfo(*pItem);
 535                     }
 536                     bReturn = true;
 537                   }
 538                   break;
 539                 }
 540               }
 541               break;
 542             case ACTION_SHOW_INFO:
 543               CServiceBroker::GetPVRManager().Get<PVR::GUI::EPG>().ShowEPGInfo(*pItem);
 544               bReturn = true;
 545               break;
 546             case ACTION_PLAYER_PLAY:
 547               CServiceBroker::GetPVRManager().Get<PVR::GUI::Playback>().SwitchToChannel(*pItem);
 548               bReturn = true;
 549               break;
 550             case ACTION_RECORD:
 551               CServiceBroker::GetPVRManager().Get<PVR::GUI::Timers>().ToggleTimer(*pItem);
 552               bReturn = true;
 553               break;
 554             case ACTION_PVR_SHOW_TIMER_RULE:
 555               CServiceBroker::GetPVRManager().Get<PVR::GUI::Timers>().AddTimerRule(*pItem, true,
 556                                                                                    false);
 557               bReturn = true;
 558               break;
 559             case ACTION_CONTEXT_MENU:
 560             case ACTION_MOUSE_RIGHT_CLICK:
 561               OnPopupMenu(GetCurrentListItemIndex(pItem));
 562               bReturn = true;
 563               break;
 564           }
 565         }
 566       }
 567       else if (message.GetSenderId() == CONTROL_BTNVIEWASICONS ||
 568                message.GetSenderId() == CONTROL_BTNSORTBY ||
 569                message.GetSenderId() == CONTROL_BTNSORTASC)
 570       {
 571         RefreshView(message, false);
 572         bReturn = true;
 573       }
 574       break;
 575     }
 576     case GUI_MSG_CHANGE_SORT_DIRECTION:
 577     case GUI_MSG_CHANGE_SORT_METHOD:
 578     case GUI_MSG_CHANGE_VIEW_MODE:
 579     {
 580       RefreshView(message, message.GetMessage() == GUI_MSG_CHANGE_VIEW_MODE);
 581       bReturn = true;
 582       break;
 583     }
 584     case GUI_MSG_REFRESH_LIST:
 585     {
 586       switch (static_cast<PVREvent>(message.GetParam1()))
 587       {
 588         case PVREvent::ManagerStarted:
 589           if (InitChannelGroup())
 590             InitEpgGridControl();
 591           break;
 592
 593         case PVREvent::ChannelGroup:
 594         case PVREvent::ChannelGroupInvalidated:
 595         case PVREvent::ClientsInvalidated:
 596         case PVREvent::ChannelPlaybackStopped:
 597         case PVREvent::Epg:
 598         case PVREvent::EpgContainer:
 599           if (InitChannelGroup())
 600             Refresh(true);
 601           break;
 602
 603         case PVREvent::Timers:
 604         case PVREvent::TimersInvalidated:
 605           SetInvalid();
 606           break;
 607
 608         default:
 609           break;
 610       }
 611       break;
 612     }
 613     case GUI_MSG_SYSTEM_WAKE:
 614       GotoCurrentProgramme();
 615       bReturn = true;
 616       break;
 617   }
 618
 619   return bReturn || CGUIWindowPVRBase::OnMessage(message);
 620 }
 621
 622 bool CGUIWindowPVRGuideBase::OnContextButton(int itemNumber, CONTEXT_BUTTON button)
 623 {
 624   if (OnContextButtonNavigate(button))
 625     return true;
 626
 627   if (itemNumber < 0 || itemNumber >= m_vecItems->Size())
 628     return false;
 629
 630   return CGUIMediaWindow::OnContextButton(itemNumber, button);
 631 }
 632
 633 namespace
 634 {
 635
 636 template<typename A>
 637 class CContextMenuFunctions : public CContextButtons
 638 {
 639 public:
 640   explicit CContextMenuFunctions(A* instance) : m_instance(instance) {}
 641
 642   void Add(bool (A::*function)(), unsigned int resId)
 643   {
 644     CContextButtons::Add(static_cast<unsigned int>(size()), resId);
 645     m_functions.emplace_back(std::bind(function, m_instance));
 646   }
 647
 648   bool Call(int idx)
 649   {
 650     if (idx < 0 || idx >= static_cast<int>(m_functions.size()))
 651       return false;
 652
 653     return m_functions[idx]();
 654   }
 655
 656 private:
 657   A* m_instance = nullptr;
 658   std::vector<std::function<bool()>> m_functions;
 659 };
 660
 661 } // unnamed namespace
 662
 663 bool CGUIWindowPVRGuideBase::OnContextButtonNavigate(CONTEXT_BUTTON button)
 664 {
 665   bool bReturn = false;
 666
 667   if (button == CONTEXT_BUTTON_NAVIGATE)
 668   {
 669     if (g_SkinInfo->HasSkinFile("DialogPVRGuideControls.xml"))
 670     {
 671       // use controls dialog
 672       CGUIDialog* dialog =
 673           CServiceBroker::GetGUI()->GetWindowManager().GetDialog(WINDOW_DIALOG_PVR_GUIDE_CONTROLS);
 674       if (dialog && !dialog->IsDialogRunning())
 675       {
 676         dialog->Open();
 677       }
 678     }
 679     else
 680     {
 681       // use context menu
 682       CContextMenuFunctions<CGUIWindowPVRGuideBase> buttons(this);
 683       buttons.Add(&CGUIWindowPVRGuideBase::GotoBegin, 19063); // First programme
 684       buttons.Add(&CGUIWindowPVRGuideBase::Go12HoursBack, 19317); // 12 hours back
 685       buttons.Add(&CGUIWindowPVRGuideBase::GotoCurrentProgramme, 19070); // Current programme
 686       buttons.Add(&CGUIWindowPVRGuideBase::Go12HoursForward, 19318); // 12 hours forward
 687       buttons.Add(&CGUIWindowPVRGuideBase::GotoEnd, 19064); // Last programme
 688       buttons.Add(&CGUIWindowPVRGuideBase::OpenDateSelectionDialog, 19288); // Date selector
 689       buttons.Add(&CGUIWindowPVRGuideBase::GotoFirstChannel, 19322); // First channel
 690       if (CServiceBroker::GetPVRManager().PlaybackState()->IsPlayingTV() ||
 691           CServiceBroker::GetPVRManager().PlaybackState()->IsPlayingRadio() ||
 692           CServiceBroker::GetPVRManager().PlaybackState()->IsPlayingEpgTag())
 693         buttons.Add(&CGUIWindowPVRGuideBase::GotoPlayingChannel, 19323); // Playing channel
 694       buttons.Add(&CGUIWindowPVRGuideBase::GotoLastChannel, 19324); // Last channel
 695       buttons.Add(&CGUIWindowPVRBase::ActivatePreviousChannelGroup, 19319); // Previous group
 696       buttons.Add(&CGUIWindowPVRBase::ActivateNextChannelGroup, 19320); // Next group
 697       buttons.Add(&CGUIWindowPVRBase::OpenChannelGroupSelectionDialog, 19321); // Group selector
 698
 699       int buttonIdx = 0;
 700       int lastButtonIdx = 2; // initially select "Current programme"
 701
 702       // loop until canceled
 703       while (buttonIdx >= 0)
 704       {
 705         buttonIdx = CGUIDialogContextMenu::Show(buttons, lastButtonIdx);
 706         lastButtonIdx = buttonIdx;
 707         buttons.Call(buttonIdx);
 708       }
 709     }
 710     bReturn = true;
 711   }
 712
 713   return bReturn;
 714 }
 715
 716 bool CGUIWindowPVRGuideBase::RefreshTimelineItems()
 717 {
 718   if (m_bRefreshTimelineItems || m_bSyncRefreshTimelineItems)
 719   {
 720     m_bRefreshTimelineItems = false;
 721     m_bSyncRefreshTimelineItems = false;
 722
 723     CGUIEPGGridContainer* epgGridContainer = GetGridControl();
 724     if (epgGridContainer)
 725     {
 726       const std::shared_ptr<CPVRChannelGroup> group(GetChannelGroup());
 727       if (!group)
 728         return false;
 729
 730       CPVREpgContainer& epgContainer = CServiceBroker::GetPVRManager().EpgContainer();
 731
 732       const std::pair<CDateTime, CDateTime> dates = epgContainer.GetFirstAndLastEPGDate();
 733       CDateTime startDate = dates.first;
 734       CDateTime endDate = dates.second;
 735       const CDateTime currentDate = CDateTime::GetUTCDateTime();
 736
 737       if (!startDate.IsValid())
 738         startDate = currentDate;
 739
 740       if (!endDate.IsValid() || endDate < startDate)
 741         endDate = startDate;
 742
 743       // limit start to past days to display
 744       const int iPastDays = epgContainer.GetPastDaysToDisplay();
 745       const CDateTime maxPastDate(currentDate - CDateTimeSpan(iPastDays, 0, 0, 0));
 746       if (startDate < maxPastDate)
 747         startDate = maxPastDate;
 748
 749       // limit end to future days to display
 750       const int iFutureDays = epgContainer.GetFutureDaysToDisplay();
 751       const CDateTime maxFutureDate(currentDate + CDateTimeSpan(iFutureDays, 0, 0, 0));
 752       if (endDate > maxFutureDate)
 753         endDate = maxFutureDate;
 754
 755       std::unique_ptr<CFileItemList> channels(new CFileItemList);
 756       const std::vector<std::shared_ptr<CPVRChannelGroupMember>> groupMembers =
 757           group->GetMembers(CPVRChannelGroup::Include::ONLY_VISIBLE);
 758
 759       for (const auto& groupMember : groupMembers)
 760       {
 761         channels->Add(std::make_shared<CFileItem>(groupMember));
 762       }
 763
 764       if (m_guiState)
 765         channels->Sort(m_guiState->GetSortMethod());
 766
 767       epgGridContainer->SetTimelineItems(channels, startDate, endDate);
 768
 769       {
 770         std::unique_lock<CCriticalSection> lock(m_critSection);
 771         m_cachedChannelGroup = group;
 772       }
 773       return true;
 774     }
 775   }
 776   return false;
 777 }
 778
 779 bool CGUIWindowPVRGuideBase::GotoBegin()
 780 {
 781   GetGridControl()->GoToBegin();
 782   return true;
 783 }
 784
 785 bool CGUIWindowPVRGuideBase::GotoEnd()
 786 {
 787   GetGridControl()->GoToEnd();
 788   return true;
 789 }
 790
 791 bool CGUIWindowPVRGuideBase::GotoCurrentProgramme()
 792 {
 793   const CPVRManager& mgr = CServiceBroker::GetPVRManager();
 794   std::shared_ptr<CPVRChannel> channel = mgr.PlaybackState()->GetPlayingChannel();
 795
 796   if (!channel)
 797   {
 798     const std::shared_ptr<const CPVREpgInfoTag> playingTag =
 799         mgr.PlaybackState()->GetPlayingEpgTag();
 800     if (playingTag)
 801       channel = mgr.ChannelGroups()->GetChannelForEpgTag(playingTag);
 802   }
 803
 804   if (channel)
 805     GetGridControl()->GoToDate(
 806         mgr.PlaybackState()->GetPlaybackTime(channel->ClientID(), channel->UniqueID()));
 807   else
 808     GetGridControl()->GoToNow();
 809
 810   return true;
 811 }
 812
 813 bool CGUIWindowPVRGuideBase::OpenDateSelectionDialog()
 814 {
 815   bool bReturn = false;
 816
 817   KODI::TIME::SystemTime date;
 818   CGUIEPGGridContainer* epgGridContainer = GetGridControl();
 819   epgGridContainer->GetSelectedDate().GetAsSystemTime(date);
 820
 821   if (CGUIDialogNumeric::ShowAndGetDate(date, g_localizeStrings.Get(19288))) /* Go to date */
 822   {
 823     epgGridContainer->GoToDate(CDateTime(date));
 824     bReturn = true;
 825   }
 826
 827   return bReturn;
 828 }
 829
 830 bool CGUIWindowPVRGuideBase::Go12HoursBack()
 831 {
 832   return GotoDate(-12);
 833 }
 834
 835 bool CGUIWindowPVRGuideBase::Go12HoursForward()
 836 {
 837   return GotoDate(+12);
 838 }
 839
 840 bool CGUIWindowPVRGuideBase::GotoDate(int deltaHours)
 841 {
 842   CGUIEPGGridContainer* epgGridContainer = GetGridControl();
 843   epgGridContainer->GoToDate(epgGridContainer->GetSelectedDate() +
 844                              CDateTimeSpan(0, deltaHours, 0, 0));
 845   return true;
 846 }
 847
 848 bool CGUIWindowPVRGuideBase::GotoFirstChannel()
 849 {
 850   GetGridControl()->GoToFirstChannel();
 851   return true;
 852 }
 853
 854 bool CGUIWindowPVRGuideBase::GotoLastChannel()
 855 {
 856   GetGridControl()->GoToLastChannel();
 857   return true;
 858 }
 859
 860 bool CGUIWindowPVRGuideBase::GotoPlayingChannel()
 861 {
 862   const CPVRManager& mgr = CServiceBroker::GetPVRManager();
 863   std::shared_ptr<CPVRChannel> channel = mgr.PlaybackState()->GetPlayingChannel();
 864
 865   if (!channel)
 866   {
 867     const std::shared_ptr<const CPVREpgInfoTag> playingTag =
 868         mgr.PlaybackState()->GetPlayingEpgTag();
 869     if (playingTag)
 870       channel = mgr.ChannelGroups()->GetChannelForEpgTag(playingTag);
 871   }
 872
 873   if (channel)
 874   {
 875     GetGridControl()->SetChannel(channel);
 876     return true;
 877   }
 878   return false;
 879 }
 880
 881 void CGUIWindowPVRGuideBase::OnInputDone()
 882 {
 883   const CPVRChannelNumber channelNumber = GetChannelNumber();
 884   if (channelNumber.IsValid())
 885   {
 886     GetGridControl()->SetChannel(channelNumber);
 887   }
 888 }
 889
 890 void CGUIWindowPVRGuideBase::GetChannelNumbers(std::vector<std::string>& channelNumbers)
 891 {
 892   const std::shared_ptr<const CPVRChannelGroup> group = GetChannelGroup();
 893   if (group)
 894     group->GetChannelNumbers(channelNumbers);
 895 }
 896
 897 CPVRRefreshTimelineItemsThread::CPVRRefreshTimelineItemsThread(CGUIWindowPVRGuideBase* pGuideWindow)
 898   : CThread("epg-grid-refresh-timeline-items"),
 899     m_pGuideWindow(pGuideWindow),
 900     m_ready(true),
 901     m_done(false)
 902 {
 903 }
 904
 905 CPVRRefreshTimelineItemsThread::~CPVRRefreshTimelineItemsThread()
 906 {
 907   // Note: CThread dtor will also call StopThread(true), but if thread worker function exits that
 908   //       late, it might access member variables of this which are already destroyed. Thus, stop
 909   //       the thread worker here and synchronously, while all members of this are still alive.
 910   StopThread(true);
 911 }
 912
 913 void CPVRRefreshTimelineItemsThread::Stop()
 914 {
 915   StopThread(false);
 916   m_ready.Set(); // wake up the worker thread to let it exit
 917 }
 918
 919 void CPVRRefreshTimelineItemsThread::DoRefresh(bool bWait)
 920 {
 921   m_ready.Set(); // wake up the worker thread
 922
 923   if (bWait)
 924   {
 925     m_done.Reset();
 926     CGUIDialogBusy::WaitOnEvent(m_done, 100, false);
 927   }
 928 }
 929
 930 void CPVRRefreshTimelineItemsThread::Process()
 931 {
 932   static const int BOOSTED_SLEEPS_THRESHOLD = 4;
 933
 934   int iLastEpgItemsCount = 0;
 935   int iUpdatesWithoutChange = 0;
 936
 937   while (!m_bStop)
 938   {
 939     m_done.Reset();
 940
 941     if (m_pGuideWindow->RefreshTimelineItems() && !m_bStop)
 942     {
 943       CGUIMessage m(GUI_MSG_REFRESH_LIST, m_pGuideWindow->GetID(), 0,
 944                     static_cast<int>(PVREvent::Epg));
 945       CServiceBroker::GetAppMessenger()->SendGUIMessage(m);
 946     }
 947
 948     if (m_bStop)
 949       break;
 950
 951     m_done.Set();
 952
 953     // in order to fill the guide window asap, use a short update interval until we the
 954     // same amount of epg events for BOOSTED_SLEEPS_THRESHOLD + 1 times in a row .
 955     if (iUpdatesWithoutChange < BOOSTED_SLEEPS_THRESHOLD)
 956     {
 957       int iCurrentEpgItemsCount = m_pGuideWindow->CurrentDirectory().Size();
 958
 959       if (iCurrentEpgItemsCount == iLastEpgItemsCount)
 960         iUpdatesWithoutChange++;
 961       else
 962         iUpdatesWithoutChange = 0; // reset
 963
 964       iLastEpgItemsCount = iCurrentEpgItemsCount;
 965
 966       m_ready.Wait(1000ms); // boosted update cycle
 967     }
 968     else
 969     {
 970       m_ready.Wait(5000ms); // normal update cycle
 971     }
 972
 973     m_ready.Reset();
 974   }
 975
 976   m_ready.Reset();
 977   m_done.Set();
 978 }
 979
 980 std::string CGUIWindowPVRTVGuide::GetRootPath() const
 981 {
 982   return "pvr://guide/tv/";
 983 }
 984
 985 std::string CGUIWindowPVRRadioGuide::GetRootPath() const
 986 {
 987   return "pvr://guide/radio/";
 988 }