xbmc/pvr/guilib/PVRGUIActionsTimers.cpp

   1 /*
   2  *  Copyright (C) 2016-2022 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 "PVRGUIActionsTimers.h"
  10
  11 #include "FileItem.h"
  12 #include "ServiceBroker.h"
  13 #include "dialogs/GUIDialogProgress.h"
  14 #include "dialogs/GUIDialogSelect.h"
  15 #include "dialogs/GUIDialogYesNo.h"
  16 #include "guilib/GUIComponent.h"
  17 #include "guilib/GUIWindowManager.h"
  18 #include "guilib/LocalizeStrings.h"
  19 #include "guilib/WindowIDs.h"
  20 #include "messaging/helpers/DialogHelper.h"
  21 #include "messaging/helpers/DialogOKHelper.h"
  22 #include "pvr/PVREventLogJob.h"
  23 #include "pvr/PVRItem.h"
  24 #include "pvr/PVRManager.h"
  25 #include "pvr/PVRPlaybackState.h"
  26 #include "pvr/addons/PVRClient.h"
  27 #include "pvr/channels/PVRChannel.h"
  28 #include "pvr/channels/PVRChannelGroupMember.h"
  29 #include "pvr/dialogs/GUIDialogPVRTimerSettings.h"
  30 #include "pvr/epg/EpgInfoTag.h"
  31 #include "pvr/guilib/PVRGUIActionsChannels.h"
  32 #include "pvr/guilib/PVRGUIActionsParentalControl.h"
  33 #include "pvr/guilib/PVRGUIActionsPlayback.h"
  34 #include "pvr/recordings/PVRRecording.h"
  35 #include "pvr/timers/PVRTimerInfoTag.h"
  36 #include "pvr/timers/PVRTimers.h"
  37 #include "settings/Settings.h"
  38 #include "utils/StringUtils.h"
  39 #include "utils/SystemInfo.h"
  40 #include "utils/Variant.h"
  41 #include "utils/log.h"
  42
  43 #include <algorithm>
  44 #include <map>
  45 #include <memory>
  46 #include <string>
  47 #include <thread>
  48 #include <utility>
  49
  50 using namespace PVR;
  51 using namespace KODI::MESSAGING;
  52
  53 CPVRGUIActionsTimers::CPVRGUIActionsTimers()
  54   : m_settings({CSettings::SETTING_PVRRECORD_INSTANTRECORDTIME,
  55                 CSettings::SETTING_PVRRECORD_INSTANTRECORDACTION,
  56                 CSettings::SETTING_PVRREMINDERS_AUTOCLOSEDELAY,
  57                 CSettings::SETTING_PVRREMINDERS_AUTORECORD,
  58                 CSettings::SETTING_PVRREMINDERS_AUTOSWITCH})
  59 {
  60 }
  61
  62 bool CPVRGUIActionsTimers::ShowTimerSettings(const std::shared_ptr<CPVRTimerInfoTag>& timer) const
  63 {
  64   CGUIDialogPVRTimerSettings* pDlgInfo =
  65       CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogPVRTimerSettings>(
  66           WINDOW_DIALOG_PVR_TIMER_SETTING);
  67   if (!pDlgInfo)
  68   {
  69     CLog::LogF(LOGERROR, "Unable to get WINDOW_DIALOG_PVR_TIMER_SETTING!");
  70     return false;
  71   }
  72
  73   pDlgInfo->SetTimer(timer);
  74   pDlgInfo->Open();
  75
  76   return pDlgInfo->IsConfirmed();
  77 }
  78
  79 bool CPVRGUIActionsTimers::AddReminder(const CFileItem& item) const
  80 {
  81   const std::shared_ptr<CPVREpgInfoTag> epgTag = CPVRItem(item).GetEpgInfoTag();
  82   if (!epgTag)
  83   {
  84     CLog::LogF(LOGERROR, "No epg tag!");
  85     return false;
  86   }
  87
  88   if (CServiceBroker::GetPVRManager().Timers()->GetTimerForEpgTag(epgTag))
  89   {
  90     HELPERS::ShowOKDialogText(CVariant{19033}, // "Information"
  91                               CVariant{19034}); // "There is already a timer set for this event"
  92     return false;
  93   }
  94
  95   const std::shared_ptr<CPVRTimerInfoTag> newTimer =
  96       CPVRTimerInfoTag::CreateReminderFromEpg(epgTag);
  97   if (!newTimer)
  98   {
  99     HELPERS::ShowOKDialogText(CVariant{19033}, // "Information"
 100                               CVariant{19094}); // Timer creation failed. Unsupported timer type.
 101     return false;
 102   }
 103
 104   return AddTimer(newTimer);
 105 }
 106
 107 bool CPVRGUIActionsTimers::AddTimer(bool bRadio) const
 108 {
 109   const std::shared_ptr<CPVRTimerInfoTag> newTimer(new CPVRTimerInfoTag(bRadio));
 110   if (ShowTimerSettings(newTimer))
 111   {
 112     return AddTimer(newTimer);
 113   }
 114   return false;
 115 }
 116
 117 bool CPVRGUIActionsTimers::AddTimer(const CFileItem& item, bool bShowTimerSettings) const
 118 {
 119   return AddTimer(item, false, bShowTimerSettings, false);
 120 }
 121
 122 bool CPVRGUIActionsTimers::AddTimerRule(const CFileItem& item,
 123                                         bool bShowTimerSettings,
 124                                         bool bFallbackToOneShotTimer) const
 125 {
 126   return AddTimer(item, true, bShowTimerSettings, bFallbackToOneShotTimer);
 127 }
 128
 129 bool CPVRGUIActionsTimers::AddTimer(const CFileItem& item,
 130                                     bool bCreateRule,
 131                                     bool bShowTimerSettings,
 132                                     bool bFallbackToOneShotTimer) const
 133 {
 134   const std::shared_ptr<CPVRChannel> channel(CPVRItem(item).GetChannel());
 135   if (!channel)
 136   {
 137     CLog::LogF(LOGERROR, "No channel!");
 138     return false;
 139   }
 140
 141   if (CServiceBroker::GetPVRManager().Get<PVR::GUI::Parental>().CheckParentalLock(channel) !=
 142       ParentalCheckResult::SUCCESS)
 143     return false;
 144
 145   std::shared_ptr<CPVREpgInfoTag> epgTag = CPVRItem(item).GetEpgInfoTag();
 146   if (epgTag)
 147   {
 148     if (epgTag->IsGapTag())
 149       epgTag.reset(); // for gap tags, we can only create instant timers
 150   }
 151   else if (bCreateRule)
 152   {
 153     CLog::LogF(LOGERROR, "No epg tag!");
 154     return false;
 155   }
 156
 157   std::shared_ptr<CPVRTimerInfoTag> timer(
 158       bCreateRule || !epgTag ? nullptr
 159                              : CServiceBroker::GetPVRManager().Timers()->GetTimerForEpgTag(epgTag));
 160   std::shared_ptr<CPVRTimerInfoTag> rule(
 161       bCreateRule ? CServiceBroker::GetPVRManager().Timers()->GetTimerRule(timer) : nullptr);
 162   if (timer || rule)
 163   {
 164     HELPERS::ShowOKDialogText(
 165         CVariant{19033},
 166         CVariant{19034}); // "Information", "There is already a timer set for this event"
 167     return false;
 168   }
 169
 170   std::shared_ptr<CPVRTimerInfoTag> newTimer(
 171       epgTag ? CPVRTimerInfoTag::CreateFromEpg(epgTag, bCreateRule)
 172              : CPVRTimerInfoTag::CreateInstantTimerTag(channel));
 173   if (!newTimer)
 174   {
 175     if (bCreateRule && bFallbackToOneShotTimer)
 176       newTimer = CPVRTimerInfoTag::CreateFromEpg(epgTag, false);
 177
 178     if (!newTimer)
 179     {
 180       HELPERS::ShowOKDialogText(
 181           CVariant{19033}, // "Information"
 182           bCreateRule ? CVariant{19095} // Timer rule creation failed. Unsupported timer type.
 183                       : CVariant{19094}); // Timer creation failed. Unsupported timer type.
 184       return false;
 185     }
 186   }
 187
 188   if (bShowTimerSettings)
 189   {
 190     if (!ShowTimerSettings(newTimer))
 191       return false;
 192   }
 193
 194   return AddTimer(newTimer);
 195 }
 196
 197 bool CPVRGUIActionsTimers::AddTimer(const std::shared_ptr<CPVRTimerInfoTag>& item) const
 198 {
 199   if (!item->Channel() && !item->GetTimerType()->IsEpgBasedTimerRule())
 200   {
 201     CLog::LogF(LOGERROR, "No channel given");
 202     HELPERS::ShowOKDialogText(
 203         CVariant{257},
 204         CVariant{
 205             19109}); // "Error", "Could not save the timer. Check the log for more information about this message."
 206     return false;
 207   }
 208
 209   if (!item->IsTimerRule() && item->GetEpgInfoTag() && !item->GetEpgInfoTag()->IsRecordable())
 210   {
 211     HELPERS::ShowOKDialogText(
 212         CVariant{19033},
 213         CVariant{19189}); // "Information", "The PVR backend does not allow to record this event."
 214     return false;
 215   }
 216
 217   if (CServiceBroker::GetPVRManager().Get<PVR::GUI::Parental>().CheckParentalLock(
 218           item->Channel()) != ParentalCheckResult::SUCCESS)
 219     return false;
 220
 221   if (!CServiceBroker::GetPVRManager().Timers()->AddTimer(item))
 222   {
 223     HELPERS::ShowOKDialogText(
 224         CVariant{257},
 225         CVariant{
 226             19109}); // "Error", "Could not save the timer. Check the log for more information about this message."
 227     return false;
 228   }
 229
 230   return true;
 231 }
 232
 233 namespace
 234 {
 235 enum PVRRECORD_INSTANTRECORDACTION
 236 {
 237   NONE = -1,
 238   RECORD_CURRENT_SHOW = 0,
 239   RECORD_INSTANTRECORDTIME = 1,
 240   ASK = 2,
 241   RECORD_30_MINUTES = 3,
 242   RECORD_60_MINUTES = 4,
 243   RECORD_120_MINUTES = 5,
 244   RECORD_NEXT_SHOW = 6
 245 };
 246
 247 class InstantRecordingActionSelector
 248 {
 249 public:
 250   explicit InstantRecordingActionSelector(int iInstantRecordTime);
 251   virtual ~InstantRecordingActionSelector() = default;
 252
 253   void AddAction(PVRRECORD_INSTANTRECORDACTION eAction, const std::string& title);
 254   void PreSelectAction(PVRRECORD_INSTANTRECORDACTION eAction);
 255   PVRRECORD_INSTANTRECORDACTION Select();
 256
 257 private:
 258   int m_iInstantRecordTime;
 259   CGUIDialogSelect* m_pDlgSelect; // not owner!
 260   std::map<PVRRECORD_INSTANTRECORDACTION, int> m_actions;
 261 };
 262
 263 InstantRecordingActionSelector::InstantRecordingActionSelector(int iInstantRecordTime)
 264   : m_iInstantRecordTime(iInstantRecordTime),
 265     m_pDlgSelect(CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(
 266         WINDOW_DIALOG_SELECT))
 267 {
 268   if (m_pDlgSelect)
 269   {
 270     m_pDlgSelect->Reset();
 271     m_pDlgSelect->SetMultiSelection(false);
 272     m_pDlgSelect->SetHeading(CVariant{19086}); // Instant recording action
 273   }
 274   else
 275   {
 276     CLog::LogF(LOGERROR, "Unable to obtain WINDOW_DIALOG_SELECT instance");
 277   }
 278 }
 279
 280 void InstantRecordingActionSelector::AddAction(PVRRECORD_INSTANTRECORDACTION eAction,
 281                                                const std::string& title)
 282 {
 283   if (m_actions.find(eAction) == m_actions.end())
 284   {
 285     switch (eAction)
 286     {
 287       case RECORD_INSTANTRECORDTIME:
 288         m_pDlgSelect->Add(
 289             StringUtils::Format(g_localizeStrings.Get(19090),
 290                                 m_iInstantRecordTime)); // Record next <default duration> minutes
 291         break;
 292       case RECORD_30_MINUTES:
 293         m_pDlgSelect->Add(
 294             StringUtils::Format(g_localizeStrings.Get(19090), 30)); // Record next 30 minutes
 295         break;
 296       case RECORD_60_MINUTES:
 297         m_pDlgSelect->Add(
 298             StringUtils::Format(g_localizeStrings.Get(19090), 60)); // Record next 60 minutes
 299         break;
 300       case RECORD_120_MINUTES:
 301         m_pDlgSelect->Add(
 302             StringUtils::Format(g_localizeStrings.Get(19090), 120)); // Record next 120 minutes
 303         break;
 304       case RECORD_CURRENT_SHOW:
 305         m_pDlgSelect->Add(StringUtils::Format(g_localizeStrings.Get(19091),
 306                                               title)); // Record current show (<title>)
 307         break;
 308       case RECORD_NEXT_SHOW:
 309         m_pDlgSelect->Add(StringUtils::Format(g_localizeStrings.Get(19092),
 310                                               title)); // Record next show (<title>)
 311         break;
 312       case NONE:
 313       case ASK:
 314       default:
 315         return;
 316     }
 317
 318     m_actions.insert(std::make_pair(eAction, static_cast<int>(m_actions.size())));
 319   }
 320 }
 321
 322 void InstantRecordingActionSelector::PreSelectAction(PVRRECORD_INSTANTRECORDACTION eAction)
 323 {
 324   const auto& it = m_actions.find(eAction);
 325   if (it != m_actions.end())
 326     m_pDlgSelect->SetSelected(it->second);
 327 }
 328
 329 PVRRECORD_INSTANTRECORDACTION InstantRecordingActionSelector::Select()
 330 {
 331   PVRRECORD_INSTANTRECORDACTION eAction = NONE;
 332
 333   m_pDlgSelect->Open();
 334
 335   if (m_pDlgSelect->IsConfirmed())
 336   {
 337     int iSelection = m_pDlgSelect->GetSelectedItem();
 338     const auto it =
 339         std::find_if(m_actions.cbegin(), m_actions.cend(),
 340                      [iSelection](const auto& action) { return action.second == iSelection; });
 341
 342     if (it != m_actions.cend())
 343       eAction = (*it).first;
 344   }
 345
 346   return eAction;
 347 }
 348
 349 } // unnamed namespace
 350
 351 bool CPVRGUIActionsTimers::ToggleRecordingOnPlayingChannel()
 352 {
 353   const std::shared_ptr<CPVRChannel> channel =
 354       CServiceBroker::GetPVRManager().PlaybackState()->GetPlayingChannel();
 355   if (channel && channel->CanRecord())
 356     return SetRecordingOnChannel(
 357         channel, !CServiceBroker::GetPVRManager().Timers()->IsRecordingOnChannel(*channel));
 358
 359   return false;
 360 }
 361
 362 bool CPVRGUIActionsTimers::SetRecordingOnChannel(const std::shared_ptr<CPVRChannel>& channel,
 363                                                  bool bOnOff)
 364 {
 365   bool bReturn = false;
 366
 367   if (!channel)
 368     return bReturn;
 369
 370   if (CServiceBroker::GetPVRManager().Get<PVR::GUI::Parental>().CheckParentalLock(channel) !=
 371       ParentalCheckResult::SUCCESS)
 372     return bReturn;
 373
 374   const std::shared_ptr<const CPVRClient> client =
 375       CServiceBroker::GetPVRManager().GetClient(channel->ClientID());
 376   if (client && client->GetClientCapabilities().SupportsTimers())
 377   {
 378     /* timers are supported on this channel */
 379     if (bOnOff && !CServiceBroker::GetPVRManager().Timers()->IsRecordingOnChannel(*channel))
 380     {
 381       std::shared_ptr<CPVREpgInfoTag> epgTag;
 382       int iDuration = m_settings.GetIntValue(CSettings::SETTING_PVRRECORD_INSTANTRECORDTIME);
 383
 384       int iAction = m_settings.GetIntValue(CSettings::SETTING_PVRRECORD_INSTANTRECORDACTION);
 385       switch (iAction)
 386       {
 387         case RECORD_CURRENT_SHOW:
 388           epgTag = channel->GetEPGNow();
 389           break;
 390
 391         case RECORD_INSTANTRECORDTIME:
 392           epgTag.reset();
 393           break;
 394
 395         case ASK:
 396         {
 397           PVRRECORD_INSTANTRECORDACTION ePreselect = RECORD_INSTANTRECORDTIME;
 398           const int iDurationDefault =
 399               m_settings.GetIntValue(CSettings::SETTING_PVRRECORD_INSTANTRECORDTIME);
 400           InstantRecordingActionSelector selector(iDurationDefault);
 401           std::shared_ptr<CPVREpgInfoTag> epgTagNext;
 402
 403           // fixed length recordings
 404           selector.AddAction(RECORD_30_MINUTES, "");
 405           selector.AddAction(RECORD_60_MINUTES, "");
 406           selector.AddAction(RECORD_120_MINUTES, "");
 407
 408           if (iDurationDefault != 30 && iDurationDefault != 60 && iDurationDefault != 120)
 409             selector.AddAction(RECORD_INSTANTRECORDTIME, "");
 410
 411           // epg-based recordings
 412           epgTag = channel->GetEPGNow();
 413           if (epgTag)
 414           {
 415             bool bLocked = CServiceBroker::GetPVRManager().IsParentalLocked(epgTag);
 416
 417             // "now"
 418             const std::string currentTitle =
 419                 bLocked ? g_localizeStrings.Get(19266) /* Parental locked */ : epgTag->Title();
 420             selector.AddAction(RECORD_CURRENT_SHOW, currentTitle);
 421             ePreselect = RECORD_CURRENT_SHOW;
 422
 423             // "next"
 424             epgTagNext = channel->GetEPGNext();
 425             if (epgTagNext)
 426             {
 427               const std::string nextTitle = bLocked
 428                                                 ? g_localizeStrings.Get(19266) /* Parental locked */
 429                                                 : epgTagNext->Title();
 430               selector.AddAction(RECORD_NEXT_SHOW, nextTitle);
 431
 432               // be smart. if current show is almost over, preselect next show.
 433               if (epgTag->ProgressPercentage() > 90.0f)
 434                 ePreselect = RECORD_NEXT_SHOW;
 435             }
 436           }
 437
 438           if (ePreselect == RECORD_INSTANTRECORDTIME)
 439           {
 440             if (iDurationDefault == 30)
 441               ePreselect = RECORD_30_MINUTES;
 442             else if (iDurationDefault == 60)
 443               ePreselect = RECORD_60_MINUTES;
 444             else if (iDurationDefault == 120)
 445               ePreselect = RECORD_120_MINUTES;
 446           }
 447
 448           selector.PreSelectAction(ePreselect);
 449
 450           PVRRECORD_INSTANTRECORDACTION eSelected = selector.Select();
 451           switch (eSelected)
 452           {
 453             case NONE:
 454               return false; // dialog canceled
 455
 456             case RECORD_30_MINUTES:
 457               iDuration = 30;
 458               epgTag.reset();
 459               break;
 460
 461             case RECORD_60_MINUTES:
 462               iDuration = 60;
 463               epgTag.reset();
 464               break;
 465
 466             case RECORD_120_MINUTES:
 467               iDuration = 120;
 468               epgTag.reset();
 469               break;
 470
 471             case RECORD_INSTANTRECORDTIME:
 472               iDuration = iDurationDefault;
 473               epgTag.reset();
 474               break;
 475
 476             case RECORD_CURRENT_SHOW:
 477               break;
 478
 479             case RECORD_NEXT_SHOW:
 480               epgTag = epgTagNext;
 481               break;
 482
 483             default:
 484               CLog::LogF(LOGERROR,
 485                          "Unknown instant record action selection ({}), defaulting to fixed "
 486                          "length recording.",
 487                          static_cast<int>(eSelected));
 488               epgTag.reset();
 489               break;
 490           }
 491           break;
 492         }
 493
 494         default:
 495           CLog::LogF(LOGERROR,
 496                      "Unknown instant record action setting value ({}), defaulting to fixed "
 497                      "length recording.",
 498                      iAction);
 499           break;
 500       }
 501
 502       const std::shared_ptr<CPVRTimerInfoTag> newTimer(
 503           epgTag ? CPVRTimerInfoTag::CreateFromEpg(epgTag, false)
 504                  : CPVRTimerInfoTag::CreateInstantTimerTag(channel, iDuration));
 505
 506       if (newTimer)
 507         bReturn = CServiceBroker::GetPVRManager().Timers()->AddTimer(newTimer);
 508
 509       if (!bReturn)
 510         HELPERS::ShowOKDialogText(
 511             CVariant{257},
 512             CVariant{
 513                 19164}); // "Error", "Could not start recording. Check the log for more information about this message."
 514     }
 515     else if (!bOnOff && CServiceBroker::GetPVRManager().Timers()->IsRecordingOnChannel(*channel))
 516     {
 517       /* delete active timers */
 518       bReturn =
 519           CServiceBroker::GetPVRManager().Timers()->DeleteTimersOnChannel(channel, true, true);
 520
 521       if (!bReturn)
 522         HELPERS::ShowOKDialogText(
 523             CVariant{257},
 524             CVariant{
 525                 19170}); // "Error", "Could not stop recording. Check the log for more information about this message."
 526     }
 527   }
 528
 529   return bReturn;
 530 }
 531
 532 bool CPVRGUIActionsTimers::ToggleTimer(const CFileItem& item) const
 533 {
 534   if (!item.HasEPGInfoTag())
 535     return false;
 536
 537   const std::shared_ptr<const CPVRTimerInfoTag> timer(CPVRItem(item).GetTimerInfoTag());
 538   if (timer)
 539   {
 540     if (timer->IsRecording())
 541       return StopRecording(item);
 542     else
 543       return DeleteTimer(item);
 544   }
 545   else
 546     return AddTimer(item, false);
 547 }
 548
 549 bool CPVRGUIActionsTimers::ToggleTimerState(const CFileItem& item) const
 550 {
 551   if (!item.HasPVRTimerInfoTag())
 552     return false;
 553
 554   const std::shared_ptr<CPVRTimerInfoTag> timer = item.GetPVRTimerInfoTag();
 555   if (timer->IsDisabled())
 556     timer->SetState(PVR_TIMER_STATE_SCHEDULED);
 557   else
 558     timer->SetState(PVR_TIMER_STATE_DISABLED);
 559
 560   if (CServiceBroker::GetPVRManager().Timers()->UpdateTimer(timer))
 561     return true;
 562
 563   HELPERS::ShowOKDialogText(
 564       CVariant{257},
 565       CVariant{
 566           19263}); // "Error", "Could not update the timer. Check the log for more information about this message."
 567   return false;
 568 }
 569
 570 bool CPVRGUIActionsTimers::EditTimer(const CFileItem& item) const
 571 {
 572   const std::shared_ptr<CPVRTimerInfoTag> timer(CPVRItem(item).GetTimerInfoTag());
 573   if (!timer)
 574   {
 575     CLog::LogF(LOGERROR, "No timer!");
 576     return false;
 577   }
 578
 579   // clone the timer.
 580   const std::shared_ptr<CPVRTimerInfoTag> newTimer(new CPVRTimerInfoTag);
 581   newTimer->UpdateEntry(timer);
 582
 583   if (ShowTimerSettings(newTimer) &&
 584       (!timer->GetTimerType()->IsReadOnly() || timer->GetTimerType()->SupportsEnableDisable()))
 585   {
 586     if (newTimer->GetTimerType() == timer->GetTimerType())
 587     {
 588       if (CServiceBroker::GetPVRManager().Timers()->UpdateTimer(newTimer))
 589         return true;
 590
 591       HELPERS::ShowOKDialogText(
 592           CVariant{257},
 593           CVariant{
 594               19263}); // "Error", "Could not update the timer. Check the log for more information about this message."
 595       return false;
 596     }
 597     else
 598     {
 599       // timer type changed. delete the original timer, then create the new timer. this order is
 600       // important. for instance, the new timer might be a rule which schedules the original timer.
 601       // deleting the original timer after creating the rule would do literally this and we would
 602       // end up with one timer missing wrt to the rule defined by the new timer.
 603       if (DeleteTimer(timer, timer->IsRecording(), false))
 604       {
 605         if (AddTimer(newTimer))
 606           return true;
 607
 608         // rollback.
 609         return AddTimer(timer);
 610       }
 611     }
 612   }
 613   return false;
 614 }
 615
 616 bool CPVRGUIActionsTimers::EditTimerRule(const CFileItem& item) const
 617 {
 618   const std::shared_ptr<CFileItem> parentTimer = GetTimerRule(item);
 619   if (parentTimer)
 620     return EditTimer(*parentTimer);
 621
 622   return false;
 623 }
 624
 625 std::shared_ptr<CFileItem> CPVRGUIActionsTimers::GetTimerRule(const CFileItem& item) const
 626 {
 627   std::shared_ptr<CPVRTimerInfoTag> timer;
 628   if (item.HasEPGInfoTag())
 629     timer = CServiceBroker::GetPVRManager().Timers()->GetTimerForEpgTag(item.GetEPGInfoTag());
 630   else if (item.HasPVRTimerInfoTag())
 631     timer = item.GetPVRTimerInfoTag();
 632
 633   if (timer)
 634   {
 635     timer = CServiceBroker::GetPVRManager().Timers()->GetTimerRule(timer);
 636     if (timer)
 637       return std::make_shared<CFileItem>(timer);
 638   }
 639   return {};
 640 }
 641
 642 bool CPVRGUIActionsTimers::DeleteTimer(const CFileItem& item) const
 643 {
 644   return DeleteTimer(item, false, false);
 645 }
 646
 647 bool CPVRGUIActionsTimers::DeleteTimerRule(const CFileItem& item) const
 648 {
 649   return DeleteTimer(item, false, true);
 650 }
 651
 652 bool CPVRGUIActionsTimers::DeleteTimer(const CFileItem& item,
 653                                        bool bIsRecording,
 654                                        bool bDeleteRule) const
 655 {
 656   std::shared_ptr<CPVRTimerInfoTag> timer;
 657   const std::shared_ptr<const CPVRRecording> recording(CPVRItem(item).GetRecording());
 658   if (recording)
 659     timer = recording->GetRecordingTimer();
 660
 661   if (!timer)
 662     timer = CPVRItem(item).GetTimerInfoTag();
 663
 664   if (!timer)
 665   {
 666     CLog::LogF(LOGERROR, "No timer!");
 667     return false;
 668   }
 669
 670   if (bDeleteRule && !timer->IsTimerRule())
 671     timer = CServiceBroker::GetPVRManager().Timers()->GetTimerRule(timer);
 672
 673   if (!timer)
 674   {
 675     CLog::LogF(LOGERROR, "No timer rule!");
 676     return false;
 677   }
 678
 679   if (bIsRecording)
 680   {
 681     if (ConfirmStopRecording(timer))
 682     {
 683       if (CServiceBroker::GetPVRManager().Timers()->DeleteTimer(timer, true, false) ==
 684           TimerOperationResult::OK)
 685         return true;
 686
 687       HELPERS::ShowOKDialogText(
 688           CVariant{257},
 689           CVariant{
 690               19170}); // "Error", "Could not stop recording. Check the log for more information about this message."
 691       return false;
 692     }
 693   }
 694   else if (!timer->GetTimerType()->AllowsDelete())
 695   {
 696     return false;
 697   }
 698   else
 699   {
 700     bool bAlsoDeleteRule(false);
 701     if (ConfirmDeleteTimer(timer, bAlsoDeleteRule))
 702       return DeleteTimer(timer, false, bAlsoDeleteRule);
 703   }
 704   return false;
 705 }
 706
 707 bool CPVRGUIActionsTimers::DeleteTimer(const std::shared_ptr<CPVRTimerInfoTag>& timer,
 708                                        bool bIsRecording,
 709                                        bool bDeleteRule) const
 710 {
 711   TimerOperationResult result =
 712       CServiceBroker::GetPVRManager().Timers()->DeleteTimer(timer, bIsRecording, bDeleteRule);
 713   switch (result)
 714   {
 715     case TimerOperationResult::RECORDING:
 716     {
 717       // recording running. ask the user if it should be deleted anyway
 718       if (HELPERS::ShowYesNoDialogText(
 719               CVariant{122}, // "Confirm delete"
 720               CVariant{
 721                   19122}) // "This timer is still recording. Are you sure you want to delete this timer?"
 722           != HELPERS::DialogResponse::CHOICE_YES)
 723         return false;
 724
 725       return DeleteTimer(timer, true, bDeleteRule);
 726     }
 727     case TimerOperationResult::OK:
 728     {
 729       return true;
 730     }
 731     case TimerOperationResult::FAILED:
 732     {
 733       HELPERS::ShowOKDialogText(
 734           CVariant{257},
 735           CVariant{
 736               19110}); // "Error", "Could not delete the timer. Check the log for more information about this message."
 737       return false;
 738     }
 739     default:
 740     {
 741       CLog::LogF(LOGERROR, "Unhandled TimerOperationResult ({})!", static_cast<int>(result));
 742       break;
 743     }
 744   }
 745   return false;
 746 }
 747
 748 bool CPVRGUIActionsTimers::ConfirmDeleteTimer(const std::shared_ptr<const CPVRTimerInfoTag>& timer,
 749                                               bool& bDeleteRule) const
 750 {
 751   bool bConfirmed(false);
 752   const std::shared_ptr<const CPVRTimerInfoTag> parentTimer(
 753       CServiceBroker::GetPVRManager().Timers()->GetTimerRule(timer));
 754
 755   if (parentTimer && parentTimer->GetTimerType()->AllowsDelete())
 756   {
 757     // timer was scheduled by a deletable timer rule. prompt user for confirmation for deleting the timer rule, including scheduled timers.
 758     bool bCancel(false);
 759     bDeleteRule = CGUIDialogYesNo::ShowAndGetInput(
 760         CVariant{122}, // "Confirm delete"
 761         CVariant{
 762             840}, // "Do you want to delete only this timer or also the timer rule that has scheduled it?"
 763         CVariant{""}, CVariant{timer->Title()}, bCancel, CVariant{841}, // "Only this"
 764         CVariant{593}, // "All"
 765         0); // no autoclose
 766     bConfirmed = !bCancel;
 767   }
 768   else
 769   {
 770     bDeleteRule = false;
 771
 772     // prompt user for confirmation for deleting the timer
 773     bConfirmed = CGUIDialogYesNo::ShowAndGetInput(
 774         CVariant{122}, // "Confirm delete"
 775         timer->IsTimerRule()
 776             ? CVariant{845}
 777             // "Are you sure you want to delete this timer rule and all timers it has scheduled?"
 778             : CVariant{846}, // "Are you sure you want to delete this timer?"
 779         CVariant{""}, CVariant{timer->Title()});
 780   }
 781
 782   return bConfirmed;
 783 }
 784
 785 bool CPVRGUIActionsTimers::StopRecording(const CFileItem& item) const
 786 {
 787   if (!DeleteTimer(item, true, false))
 788     return false;
 789
 790   CServiceBroker::GetPVRManager().TriggerRecordingsUpdate();
 791   return true;
 792 }
 793
 794 bool CPVRGUIActionsTimers::ConfirmStopRecording(
 795     const std::shared_ptr<const CPVRTimerInfoTag>& timer) const
 796 {
 797   return CGUIDialogYesNo::ShowAndGetInput(
 798       CVariant{847}, // "Confirm stop recording"
 799       CVariant{848}, // "Are you sure you want to stop this recording?"
 800       CVariant{""}, CVariant{timer->Title()});
 801 }
 802
 803 namespace
 804 {
 805 std::string GetAnnouncerText(const std::shared_ptr<const CPVRTimerInfoTag>& timer,
 806                              int idEpg,
 807                              int idNoEpg)
 808 {
 809   std::string text;
 810   if (timer->IsEpgBased())
 811   {
 812     text = StringUtils::Format(g_localizeStrings.Get(idEpg),
 813                                timer->Title(), // tv show title
 814                                timer->ChannelName(),
 815                                timer->StartAsLocalTime().GetAsLocalizedDateTime(false, false));
 816   }
 817   else
 818   {
 819     text = StringUtils::Format(g_localizeStrings.Get(idNoEpg), timer->ChannelName(),
 820                                timer->StartAsLocalTime().GetAsLocalizedDateTime(false, false));
 821   }
 822   return text;
 823 }
 824
 825 void AddEventLogEntry(const std::shared_ptr<const CPVRTimerInfoTag>& timer, int idEpg, int idNoEpg)
 826 {
 827   std::string name;
 828   std::string icon;
 829
 830   const std::shared_ptr<const CPVRClient> client =
 831       CServiceBroker::GetPVRManager().GetClient(timer->GetTimerType()->GetClientId());
 832   if (client)
 833   {
 834     name = client->GetFriendlyName();
 835     icon = client->Icon();
 836   }
 837   else
 838   {
 839     name = g_sysinfo.GetAppName();
 840     icon = "special://xbmc/media/icon256x256.png";
 841   }
 842
 843   CPVREventLogJob* job = new CPVREventLogJob;
 844   job->AddEvent(false, // do not display a toast, only log event
 845                 EventLevel::Information, // info, no error
 846                 name, GetAnnouncerText(timer, idEpg, idNoEpg), icon);
 847   CServiceBroker::GetJobManager()->AddJob(job, nullptr);
 848 }
 849 } // unnamed namespace
 850
 851 void CPVRGUIActionsTimers::AnnounceReminder(const std::shared_ptr<CPVRTimerInfoTag>& timer) const
 852 {
 853   if (!timer->IsReminder())
 854   {
 855     CLog::LogF(LOGERROR, "No reminder timer!");
 856     return;
 857   }
 858
 859   if (timer->EndAsUTC() < CDateTime::GetUTCDateTime())
 860   {
 861     // expired. timer end is in the past. write event log entry.
 862     AddEventLogEntry(timer, 19305, 19306); // Deleted missed PVR reminder ...
 863     return;
 864   }
 865
 866   if (CServiceBroker::GetPVRManager().PlaybackState()->IsPlayingChannel(timer->Channel()))
 867   {
 868     // no need for an announcement. channel in question is already playing.
 869     return;
 870   }
 871
 872   // show the reminder dialog
 873   CGUIDialogProgress* dialog =
 874       CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogProgress>(
 875           WINDOW_DIALOG_PROGRESS);
 876   if (!dialog)
 877     return;
 878
 879   dialog->Reset();
 880
 881   dialog->SetHeading(CVariant{19312}); // "PVR reminder"
 882   dialog->ShowChoice(0, CVariant{19165}); // "Switch"
 883
 884   std::string text = GetAnnouncerText(timer, 19307, 19308); // Reminder for ...
 885
 886   bool bCanRecord = false;
 887   const std::shared_ptr<const CPVRClient> client =
 888       CServiceBroker::GetPVRManager().GetClient(timer->ClientID());
 889   if (client && client->GetClientCapabilities().SupportsTimers())
 890   {
 891     bCanRecord = true;
 892     dialog->ShowChoice(1, CVariant{264}); // "Record"
 893     dialog->ShowChoice(2, CVariant{222}); // "Cancel"
 894
 895     if (m_settings.GetBoolValue(CSettings::SETTING_PVRREMINDERS_AUTORECORD))
 896       text += "\n\n" + g_localizeStrings.Get(
 897                            19309); // (Auto-close of this reminder will schedule a recording...)
 898     else if (m_settings.GetBoolValue(CSettings::SETTING_PVRREMINDERS_AUTOSWITCH))
 899       text += "\n\n" + g_localizeStrings.Get(
 900                            19331); // (Auto-close of this reminder will switch to channel...)
 901   }
 902   else
 903   {
 904     dialog->ShowChoice(1, CVariant{222}); // "Cancel"
 905   }
 906
 907   dialog->SetText(text);
 908   dialog->SetPercentage(100);
 909
 910   dialog->Open();
 911
 912   int result = CGUIDialogProgress::CHOICE_NONE;
 913
 914   static constexpr int PROGRESS_TIMESLICE_MILLISECS = 50;
 915
 916   const int iWait = m_settings.GetIntValue(CSettings::SETTING_PVRREMINDERS_AUTOCLOSEDELAY) * 1000;
 917   int iRemaining = iWait;
 918   while (iRemaining > 0)
 919   {
 920     result = dialog->GetChoice();
 921     if (result != CGUIDialogProgress::CHOICE_NONE)
 922       break;
 923
 924     std::this_thread::sleep_for(std::chrono::milliseconds(PROGRESS_TIMESLICE_MILLISECS));
 925
 926     iRemaining -= PROGRESS_TIMESLICE_MILLISECS;
 927     dialog->SetPercentage(iRemaining * 100 / iWait);
 928     dialog->Progress();
 929   }
 930
 931   dialog->Close();
 932
 933   bool bAutoClosed = (iRemaining <= 0);
 934   bool bSwitch = (result == 0);
 935   bool bRecord = (result == 1);
 936
 937   if (bAutoClosed)
 938   {
 939     bRecord = (bCanRecord && m_settings.GetBoolValue(CSettings::SETTING_PVRREMINDERS_AUTORECORD));
 940     bSwitch = m_settings.GetBoolValue(CSettings::SETTING_PVRREMINDERS_AUTOSWITCH);
 941   }
 942
 943   if (bRecord)
 944   {
 945     std::shared_ptr<CPVRTimerInfoTag> newTimer;
 946
 947     std::shared_ptr<CPVREpgInfoTag> epgTag = timer->GetEpgInfoTag();
 948     if (epgTag)
 949     {
 950       newTimer = CPVRTimerInfoTag::CreateFromEpg(epgTag, false);
 951       if (newTimer)
 952       {
 953         // an epgtag can only have max one timer - we need to clear the reminder to be able to
 954         // attach the recording timer
 955         DeleteTimer(timer, false, false);
 956       }
 957     }
 958     else
 959     {
 960       int iDuration = (timer->EndAsUTC() - timer->StartAsUTC()).GetSecondsTotal() / 60;
 961       newTimer = CPVRTimerInfoTag::CreateTimerTag(timer->Channel(), timer->StartAsUTC(), iDuration);
 962     }
 963
 964     if (newTimer)
 965     {
 966       // schedule recording
 967       AddTimer(CFileItem(newTimer), false);
 968     }
 969
 970     if (bAutoClosed)
 971     {
 972       AddEventLogEntry(timer, 19310,
 973                        19311); // Scheduled recording for auto-closed PVR reminder ...
 974     }
 975   }
 976
 977   if (bSwitch)
 978   {
 979     const std::shared_ptr<CPVRChannelGroupMember> groupMember =
 980         CServiceBroker::GetPVRManager().Get<PVR::GUI::Channels>().GetChannelGroupMember(
 981             timer->Channel());
 982     if (groupMember)
 983     {
 984       CServiceBroker::GetPVRManager().Get<PVR::GUI::Playback>().SwitchToChannel(
 985           CFileItem(groupMember), false);
 986
 987       if (bAutoClosed)
 988       {
 989         AddEventLogEntry(timer, 19332,
 990                          19333); // Switched channel for auto-closed PVR reminder ...
 991       }
 992     }
 993   }
 994 }
 995
 996 void CPVRGUIActionsTimers::AnnounceReminders() const
 997 {
 998   // Prevent multiple yesno dialogs, all on same call stack, due to gui message processing while dialog is open.
 999   if (m_bReminderAnnouncementRunning)
1000     return;
1001
1002   m_bReminderAnnouncementRunning = true;
1003   std::shared_ptr<CPVRTimerInfoTag> timer =
1004       CServiceBroker::GetPVRManager().Timers()->GetNextReminderToAnnnounce();
1005   while (timer)
1006   {
1007     AnnounceReminder(timer);
1008     timer = CServiceBroker::GetPVRManager().Timers()->GetNextReminderToAnnnounce();
1009   }
1010   m_bReminderAnnouncementRunning = false;
1011 }