xbmc/pvr/guilib/PVRGUIActionsRecordings.cpp

   1 /*
   2  *  Copyright (C) 2016-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 "PVRGUIActionsRecordings.h"
  10
  11 #include "FileItem.h"
  12 #include "FileItemList.h"
  13 #include "ServiceBroker.h"
  14 #include "Util.h"
  15 #include "dialogs/GUIDialogBusy.h"
  16 #include "dialogs/GUIDialogYesNo.h"
  17 #include "filesystem/IDirectory.h"
  18 #include "guilib/GUIComponent.h"
  19 #include "guilib/GUIWindowManager.h"
  20 #include "guilib/LocalizeStrings.h"
  21 #include "guilib/WindowIDs.h"
  22 #include "messaging/helpers/DialogHelper.h"
  23 #include "messaging/helpers/DialogOKHelper.h"
  24 #include "pvr/PVREventLogJob.h"
  25 #include "pvr/PVRItem.h"
  26 #include "pvr/PVRManager.h"
  27 #include "pvr/addons/PVRClient.h"
  28 #include "pvr/addons/PVRClients.h"
  29 #include "pvr/dialogs/GUIDialogPVRRecordingInfo.h"
  30 #include "pvr/dialogs/GUIDialogPVRRecordingSettings.h"
  31 #include "pvr/recordings/PVRRecording.h"
  32 #include "pvr/recordings/PVRRecordings.h"
  33 #include "settings/Settings.h"
  34 #include "threads/IRunnable.h"
  35 #include "utils/StringUtils.h"
  36 #include "utils/Variant.h"
  37 #include "utils/log.h"
  38
  39 #include <memory>
  40 #include <numeric>
  41 #include <string>
  42
  43 using namespace PVR;
  44 using namespace KODI::MESSAGING;
  45
  46 namespace
  47 {
  48 enum PVRRECORD_DELETE_AFTER_WATCH
  49 {
  50   // Values must match those defined in settings.xml -> pvrrecord.deleteafterwatch
  51   NO = 0,
  52   ASK = 1,
  53   YES = 2,
  54 };
  55
  56 class AsyncRecordingAction : private IRunnable
  57 {
  58 public:
  59   bool Execute(const CFileItem& item);
  60
  61 protected:
  62   AsyncRecordingAction() = default;
  63
  64 private:
  65   // IRunnable implementation
  66   void Run() override;
  67
  68   // the worker function
  69   virtual bool DoRun(const std::shared_ptr<CFileItem>& item) = 0;
  70
  71   std::shared_ptr<CFileItem> m_item;
  72   bool m_bSuccess = false;
  73 };
  74
  75 bool AsyncRecordingAction::Execute(const CFileItem& item)
  76 {
  77   m_item = std::make_shared<CFileItem>(item);
  78   CGUIDialogBusy::Wait(this, 100, false);
  79   return m_bSuccess;
  80 }
  81
  82 void AsyncRecordingAction::Run()
  83 {
  84   m_bSuccess = DoRun(m_item);
  85
  86   if (m_bSuccess)
  87     CServiceBroker::GetPVRManager().TriggerRecordingsUpdate();
  88 }
  89
  90 class AsyncRenameRecording : public AsyncRecordingAction
  91 {
  92 public:
  93   explicit AsyncRenameRecording(const std::string& strNewName) : m_strNewName(strNewName) {}
  94
  95 private:
  96   bool DoRun(const std::shared_ptr<CFileItem>& item) override
  97   {
  98     if (item->IsUsablePVRRecording())
  99     {
 100       return item->GetPVRRecordingInfoTag()->Rename(m_strNewName);
 101     }
 102     else
 103     {
 104       CLog::LogF(LOGERROR, "Cannot rename item '{}': no valid recording tag", item->GetPath());
 105       return false;
 106     }
 107   }
 108   std::string m_strNewName;
 109 };
 110
 111 class AsyncDeleteRecording : public AsyncRecordingAction
 112 {
 113 public:
 114   explicit AsyncDeleteRecording(bool bWatchedOnly = false) : m_bWatchedOnly(bWatchedOnly) {}
 115
 116 private:
 117   bool DoRun(const std::shared_ptr<CFileItem>& item) override
 118   {
 119     CFileItemList items;
 120     if (item->m_bIsFolder)
 121     {
 122       CUtil::GetRecursiveListing(item->GetPath(), items, "", XFILE::DIR_FLAG_NO_FILE_INFO);
 123     }
 124     else
 125     {
 126       items.Add(item);
 127     }
 128
 129     const auto recordings{CServiceBroker::GetPVRManager().Recordings()};
 130     return std::accumulate(
 131         items.cbegin(), items.cend(), true,
 132         [this, &recordings](bool success, const auto& itemToDelete)
 133         {
 134           return (itemToDelete->IsPVRRecording() &&
 135                   (!m_bWatchedOnly || itemToDelete->GetPVRRecordingInfoTag()->GetPlayCount() > 0) &&
 136                   !recordings->DeleteRecording(itemToDelete->GetPVRRecordingInfoTag()))
 137                      ? false
 138                      : success;
 139         });
 140   }
 141   bool m_bWatchedOnly = false;
 142 };
 143
 144 class AsyncEmptyRecordingsTrash : public AsyncRecordingAction
 145 {
 146 private:
 147   bool DoRun(const std::shared_ptr<CFileItem>& item) override
 148   {
 149     return CServiceBroker::GetPVRManager().Clients()->DeleteAllRecordingsFromTrash() ==
 150            PVR_ERROR_NO_ERROR;
 151   }
 152 };
 153
 154 class AsyncUndeleteRecording : public AsyncRecordingAction
 155 {
 156 private:
 157   bool DoRun(const std::shared_ptr<CFileItem>& item) override
 158   {
 159     if (item->IsDeletedPVRRecording())
 160     {
 161       return item->GetPVRRecordingInfoTag()->Undelete();
 162     }
 163     else
 164     {
 165       CLog::LogF(LOGERROR, "Cannot undelete item '{}': no valid recording tag", item->GetPath());
 166       return false;
 167     }
 168   }
 169 };
 170
 171 class AsyncSetRecordingPlayCount : public AsyncRecordingAction
 172 {
 173 private:
 174   bool DoRun(const std::shared_ptr<CFileItem>& item) override
 175   {
 176     const std::shared_ptr<CPVRClient> client = CServiceBroker::GetPVRManager().GetClient(*item);
 177     if (client)
 178     {
 179       const std::shared_ptr<const CPVRRecording> recording = item->GetPVRRecordingInfoTag();
 180       return client->SetRecordingPlayCount(*recording, recording->GetLocalPlayCount()) ==
 181              PVR_ERROR_NO_ERROR;
 182     }
 183     return false;
 184   }
 185 };
 186
 187 class AsyncSetRecordingLifetime : public AsyncRecordingAction
 188 {
 189 private:
 190   bool DoRun(const std::shared_ptr<CFileItem>& item) override
 191   {
 192     const std::shared_ptr<CPVRClient> client = CServiceBroker::GetPVRManager().GetClient(*item);
 193     if (client)
 194       return client->SetRecordingLifetime(*item->GetPVRRecordingInfoTag()) == PVR_ERROR_NO_ERROR;
 195     return false;
 196   }
 197 };
 198
 199 } // unnamed namespace
 200
 201 CPVRGUIActionsRecordings::CPVRGUIActionsRecordings()
 202   : m_settings({CSettings::SETTING_PVRRECORD_DELETEAFTERWATCH})
 203 {
 204 }
 205
 206 bool CPVRGUIActionsRecordings::ShowRecordingInfo(const CFileItem& item) const
 207 {
 208   if (!item.IsPVRRecording())
 209   {
 210     CLog::LogF(LOGERROR, "No recording!");
 211     return false;
 212   }
 213
 214   CGUIDialogPVRRecordingInfo* pDlgInfo =
 215       CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogPVRRecordingInfo>(
 216           WINDOW_DIALOG_PVR_RECORDING_INFO);
 217   if (!pDlgInfo)
 218   {
 219     CLog::LogF(LOGERROR, "Unable to get WINDOW_DIALOG_PVR_RECORDING_INFO!");
 220     return false;
 221   }
 222
 223   pDlgInfo->SetRecording(item);
 224   pDlgInfo->Open();
 225   return true;
 226 }
 227
 228 bool CPVRGUIActionsRecordings::EditRecording(const CFileItem& item) const
 229 {
 230   const std::shared_ptr<CPVRRecording> recording = CPVRItem(item).GetRecording();
 231   if (!recording)
 232   {
 233     CLog::LogF(LOGERROR, "No recording!");
 234     return false;
 235   }
 236
 237   std::shared_ptr<CPVRRecording> origRecording(new CPVRRecording);
 238   origRecording->Update(*recording,
 239                         *CServiceBroker::GetPVRManager().GetClient(recording->ClientID()));
 240
 241   if (!ShowRecordingSettings(recording))
 242     return false;
 243
 244   if (origRecording->m_strTitle != recording->m_strTitle)
 245   {
 246     if (!AsyncRenameRecording(recording->m_strTitle).Execute(item))
 247       CLog::LogF(LOGERROR, "Renaming recording failed!");
 248   }
 249
 250   if (origRecording->GetLocalPlayCount() != recording->GetLocalPlayCount())
 251   {
 252     if (!AsyncSetRecordingPlayCount().Execute(item))
 253       CLog::LogF(LOGERROR, "Setting recording playcount failed!");
 254   }
 255
 256   if (origRecording->LifeTime() != recording->LifeTime())
 257   {
 258     if (!AsyncSetRecordingLifetime().Execute(item))
 259       CLog::LogF(LOGERROR, "Setting recording lifetime failed!");
 260   }
 261
 262   return true;
 263 }
 264
 265 bool CPVRGUIActionsRecordings::CanEditRecording(const CFileItem& item) const
 266 {
 267   return CGUIDialogPVRRecordingSettings::CanEditRecording(item);
 268 }
 269
 270 bool CPVRGUIActionsRecordings::DeleteRecording(const CFileItem& item) const
 271 {
 272   if ((!item.IsPVRRecording() && !item.m_bIsFolder) || item.IsParentFolder())
 273     return false;
 274
 275   if (!ConfirmDeleteRecording(item))
 276     return false;
 277
 278   if (!AsyncDeleteRecording().Execute(item))
 279   {
 280     HELPERS::ShowOKDialogText(CVariant{257}, CVariant{19111}); // "Error", "PVR backend error."
 281     return false;
 282   }
 283
 284   return true;
 285 }
 286
 287 bool CPVRGUIActionsRecordings::ConfirmDeleteRecording(const CFileItem& item) const
 288 {
 289   return CGUIDialogYesNo::ShowAndGetInput(
 290       CVariant{122}, // "Confirm delete"
 291       item.m_bIsFolder
 292           ? CVariant{19113} // "Delete all recordings in this folder?"
 293           : item.GetPVRRecordingInfoTag()->IsDeleted()
 294                 ? CVariant{19294}
 295                 // "Remove this deleted recording from trash? This operation cannot be reverted."
 296                 : CVariant{19112}, // "Delete this recording?"
 297       CVariant{""}, CVariant{item.GetLabel()});
 298 }
 299
 300 bool CPVRGUIActionsRecordings::DeleteWatchedRecordings(const CFileItem& item) const
 301 {
 302   if (!item.m_bIsFolder || item.IsParentFolder())
 303     return false;
 304
 305   if (!ConfirmDeleteWatchedRecordings(item))
 306     return false;
 307
 308   if (!AsyncDeleteRecording(true).Execute(item))
 309   {
 310     HELPERS::ShowOKDialogText(CVariant{257}, CVariant{19111}); // "Error", "PVR backend error."
 311     return false;
 312   }
 313
 314   return true;
 315 }
 316
 317 bool CPVRGUIActionsRecordings::ConfirmDeleteWatchedRecordings(const CFileItem& item) const
 318 {
 319   return CGUIDialogYesNo::ShowAndGetInput(
 320       CVariant{122}, // "Confirm delete"
 321       CVariant{19328}, // "Delete all watched recordings in this folder?"
 322       CVariant{""}, CVariant{item.GetLabel()});
 323 }
 324
 325 bool CPVRGUIActionsRecordings::DeleteAllRecordingsFromTrash() const
 326 {
 327   if (!ConfirmDeleteAllRecordingsFromTrash())
 328     return false;
 329
 330   if (!AsyncEmptyRecordingsTrash().Execute({}))
 331     return false;
 332
 333   return true;
 334 }
 335
 336 bool CPVRGUIActionsRecordings::ConfirmDeleteAllRecordingsFromTrash() const
 337 {
 338   return CGUIDialogYesNo::ShowAndGetInput(
 339       CVariant{19292}, // "Delete all permanently"
 340       CVariant{
 341           19293}); // "Remove all deleted recordings from trash? This operation cannot be reverted."
 342 }
 343
 344 bool CPVRGUIActionsRecordings::UndeleteRecording(const CFileItem& item) const
 345 {
 346   if (!item.IsDeletedPVRRecording())
 347     return false;
 348
 349   if (!AsyncUndeleteRecording().Execute(item))
 350   {
 351     HELPERS::ShowOKDialogText(CVariant{257}, CVariant{19111}); // "Error", "PVR backend error."
 352     return false;
 353   }
 354
 355   return true;
 356 }
 357
 358 bool CPVRGUIActionsRecordings::ShowRecordingSettings(
 359     const std::shared_ptr<CPVRRecording>& recording) const
 360 {
 361   CGUIDialogPVRRecordingSettings* pDlgInfo =
 362       CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogPVRRecordingSettings>(
 363           WINDOW_DIALOG_PVR_RECORDING_SETTING);
 364   if (!pDlgInfo)
 365   {
 366     CLog::LogF(LOGERROR, "Unable to get WINDOW_DIALOG_PVR_RECORDING_SETTING!");
 367     return false;
 368   }
 369
 370   pDlgInfo->SetRecording(recording);
 371   pDlgInfo->Open();
 372
 373   return pDlgInfo->IsConfirmed();
 374 }
 375
 376 bool CPVRGUIActionsRecordings::ProcessDeleteAfterWatch(const CFileItem& item) const
 377 {
 378   bool deleteRecording{false};
 379
 380   const int action{m_settings.GetIntValue(CSettings::SETTING_PVRRECORD_DELETEAFTERWATCH)};
 381   switch (action)
 382   {
 383     case PVRRECORD_DELETE_AFTER_WATCH::NO:
 384       deleteRecording = false;
 385       break;
 386
 387     case PVRRECORD_DELETE_AFTER_WATCH::ASK:
 388       deleteRecording = (HELPERS::ShowYesNoDialogLines(
 389                              CVariant{860}, // "Delete after watching"
 390                              CVariant{865}, // "Do you want to delete this recording?"
 391                              CVariant{""}, CVariant{item.GetPVRRecordingInfoTag()->GetTitle()}) ==
 392                          HELPERS::DialogResponse::CHOICE_YES);
 393       break;
 394
 395     case PVRRECORD_DELETE_AFTER_WATCH::YES:
 396       deleteRecording = true;
 397       break;
 398
 399     default:
 400       CLog::LogF(LOGERROR, "Unhandled delete after watch action! Defaulting to 'no delete'.");
 401       deleteRecording = false;
 402       break;
 403   }
 404
 405   if (deleteRecording)
 406   {
 407     if (AsyncDeleteRecording().Execute(item))
 408     {
 409       CPVREventLogJob* job = new CPVREventLogJob;
 410       job->AddEvent(true, // display a toast, and log event
 411                     EventLevel::Information, // info, no error
 412                     g_localizeStrings.Get(860), // "Delete after watching"
 413                     StringUtils::Format(g_localizeStrings.Get(866), // Recording deleted: <title>
 414                                         item.GetPVRRecordingInfoTag()->GetTitle()),
 415                     item.GetPVRRecordingInfoTag()->IconPath());
 416       CServiceBroker::GetJobManager()->AddJob(job, nullptr);
 417     }
 418     else
 419     {
 420       HELPERS::ShowOKDialogText(CVariant{257}, // "Error"
 421                                 CVariant{19111}); // "PVR backend error."
 422       return false;
 423     }
 424   }
 425   return true;
 426 }
 427
 428 bool CPVRGUIActionsRecordings::IncrementPlayCount(const CFileItem& item) const
 429 {
 430   if (!item.IsPVRRecording())
 431     return false;
 432
 433   if (item.GetPVRRecordingInfoTag()->IncrementPlayCount())
 434   {
 435     // Item must now be watched (because play count > 0).
 436     return ProcessDeleteAfterWatch(item);
 437   }
 438   return false;
 439 }
 440
 441 bool CPVRGUIActionsRecordings::MarkWatched(const CFileItem& item, bool watched) const
 442 {
 443   if (!item.IsPVRRecording())
 444     return false;
 445
 446   if (CServiceBroker::GetPVRManager().Recordings()->MarkWatched(item.GetPVRRecordingInfoTag(),
 447                                                                 watched))
 448   {
 449     if (watched)
 450       return ProcessDeleteAfterWatch(item);
 451
 452     return true;
 453   }
 454   return false;
 455 }