xbmc/pvr/guilib/PVRGUIActionsDatabase.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 "PVRGUIActionsDatabase.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/ApplicationMessenger.h"
  21 #include "pvr/PVRDatabase.h"
  22 #include "pvr/PVRManager.h"
  23 #include "pvr/PVRPlaybackState.h"
  24 #include "pvr/epg/EpgContainer.h"
  25 #include "pvr/epg/EpgDatabase.h"
  26 #include "pvr/guilib/PVRGUIActionsParentalControl.h"
  27 #include "pvr/recordings/PVRRecordings.h"
  28 #include "pvr/recordings/PVRRecordingsPath.h"
  29 #include "utils/StringUtils.h"
  30 #include "utils/Variant.h"
  31 #include "utils/log.h"
  32 #include "video/VideoDatabase.h"
  33
  34 #include <memory>
  35 #include <string>
  36
  37 using namespace PVR;
  38
  39 namespace
  40 {
  41 class CPVRGUIDatabaseResetComponentsSelector
  42 {
  43 public:
  44   CPVRGUIDatabaseResetComponentsSelector() = default;
  45   virtual ~CPVRGUIDatabaseResetComponentsSelector() = default;
  46
  47   bool Select()
  48   {
  49     CGUIDialogSelect* pDlgSelect =
  50         CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(
  51             WINDOW_DIALOG_SELECT);
  52     if (!pDlgSelect)
  53     {
  54       CLog::LogF(LOGERROR, "Unable to get WINDOW_DIALOG_SELECT!");
  55       return false;
  56     }
  57
  58     CFileItemList options;
  59
  60     const std::shared_ptr<CFileItem> itemAll =
  61         std::make_shared<CFileItem>(StringUtils::Format(g_localizeStrings.Get(593))); // All
  62     itemAll->SetPath("all");
  63     options.Add(itemAll);
  64
  65     // if channels are cleared, groups, EPG data and providers must also be cleared
  66     const std::shared_ptr<CFileItem> itemChannels =
  67         std::make_shared<CFileItem>(StringUtils::Format("{}, {}, {}, {}",
  68                                                         g_localizeStrings.Get(19019), // Channels
  69                                                         g_localizeStrings.Get(19146), // Groups
  70                                                         g_localizeStrings.Get(19069), // Guide
  71                                                         g_localizeStrings.Get(19334))); // Providers
  72     itemChannels->SetPath("channels");
  73     itemChannels->Select(true); // preselect this item in dialog
  74     options.Add(itemChannels);
  75
  76     const std::shared_ptr<CFileItem> itemGroups =
  77         std::make_shared<CFileItem>(g_localizeStrings.Get(19146)); // Groups
  78     itemGroups->SetPath("groups");
  79     options.Add(itemGroups);
  80
  81     const std::shared_ptr<CFileItem> itemGuide =
  82         std::make_shared<CFileItem>(g_localizeStrings.Get(19069)); // Guide
  83     itemGuide->SetPath("guide");
  84     options.Add(itemGuide);
  85
  86     const std::shared_ptr<CFileItem> itemProviders =
  87         std::make_shared<CFileItem>(g_localizeStrings.Get(19334)); // Providers
  88     itemProviders->SetPath("providers");
  89     options.Add(itemProviders);
  90
  91     const std::shared_ptr<CFileItem> itemReminders =
  92         std::make_shared<CFileItem>(g_localizeStrings.Get(19215)); // Reminders
  93     itemReminders->SetPath("reminders");
  94     options.Add(itemReminders);
  95
  96     const std::shared_ptr<CFileItem> itemRecordings =
  97         std::make_shared<CFileItem>(g_localizeStrings.Get(19017)); // Recordings
  98     itemRecordings->SetPath("recordings");
  99     options.Add(itemRecordings);
 100
 101     const std::shared_ptr<CFileItem> itemClients =
 102         std::make_shared<CFileItem>(g_localizeStrings.Get(24019)); // PVR clients
 103     itemClients->SetPath("clients");
 104     options.Add(itemClients);
 105
 106     pDlgSelect->Reset();
 107     pDlgSelect->SetHeading(CVariant{g_localizeStrings.Get(19185)}); // "Clear data"
 108     pDlgSelect->SetItems(options);
 109     pDlgSelect->SetMultiSelection(true);
 110     pDlgSelect->Open();
 111
 112     if (!pDlgSelect->IsConfirmed())
 113       return false;
 114
 115     for (int i : pDlgSelect->GetSelectedItems())
 116     {
 117       const std::string path = options.Get(i)->GetPath();
 118
 119       m_bResetChannels |= (path == "channels" || path == "all");
 120       m_bResetGroups |= (path == "groups" || path == "all");
 121       m_bResetGuide |= (path == "guide" || path == "all");
 122       m_bResetProviders |= (path == "providers" || path == "all");
 123       m_bResetReminders |= (path == "reminders" || path == "all");
 124       m_bResetRecordings |= (path == "recordings" || path == "all");
 125       m_bResetClients |= (path == "clients" || path == "all");
 126     }
 127
 128     m_bResetGroups |= m_bResetChannels;
 129     m_bResetGuide |= m_bResetChannels;
 130     m_bResetProviders |= m_bResetChannels;
 131
 132     return (m_bResetChannels || m_bResetGroups || m_bResetGuide || m_bResetProviders ||
 133             m_bResetReminders || m_bResetRecordings || m_bResetClients);
 134   }
 135
 136   bool IsResetChannelsSelected() const { return m_bResetChannels; }
 137   bool IsResetGroupsSelected() const { return m_bResetGroups; }
 138   bool IsResetGuideSelected() const { return m_bResetGuide; }
 139   bool IsResetProvidersSelected() const { return m_bResetProviders; }
 140   bool IsResetRemindersSelected() const { return m_bResetReminders; }
 141   bool IsResetRecordingsSelected() const { return m_bResetRecordings; }
 142   bool IsResetClientsSelected() const { return m_bResetClients; }
 143
 144 private:
 145   bool m_bResetChannels = false;
 146   bool m_bResetGroups = false;
 147   bool m_bResetGuide = false;
 148   bool m_bResetProviders = false;
 149   bool m_bResetReminders = false;
 150   bool m_bResetRecordings = false;
 151   bool m_bResetClients = false;
 152 };
 153
 154 } // unnamed namespace
 155
 156 bool CPVRGUIActionsDatabase::ResetDatabase(bool bResetEPGOnly)
 157 {
 158   CGUIDialogProgress* pDlgProgress =
 159       CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogProgress>(
 160           WINDOW_DIALOG_PROGRESS);
 161   if (!pDlgProgress)
 162   {
 163     CLog::LogF(LOGERROR, "Unable to get WINDOW_DIALOG_PROGRESS!");
 164     return false;
 165   }
 166
 167   bool bResetChannels = false;
 168   bool bResetGroups = false;
 169   bool bResetGuide = false;
 170   bool bResetProviders = false;
 171   bool bResetReminders = false;
 172   bool bResetRecordings = false;
 173   bool bResetClients = false;
 174
 175   if (bResetEPGOnly)
 176   {
 177     if (!CGUIDialogYesNo::ShowAndGetInput(
 178             CVariant{19098}, // "Warning!"
 179             CVariant{19188})) // "All guide data will be cleared. Are you sure?"
 180       return false;
 181
 182     bResetGuide = true;
 183   }
 184   else
 185   {
 186     if (CServiceBroker::GetPVRManager().Get<PVR::GUI::Parental>().CheckParentalPIN() !=
 187         ParentalCheckResult::SUCCESS)
 188       return false;
 189
 190     CPVRGUIDatabaseResetComponentsSelector selector;
 191     if (!selector.Select())
 192       return false;
 193
 194     if (!CGUIDialogYesNo::ShowAndGetInput(
 195             CVariant{19098}, // "Warning!"
 196             CVariant{19186})) // "All selected data will be cleared. ... Are you sure?"
 197       return false;
 198
 199     bResetChannels = selector.IsResetChannelsSelected();
 200     bResetGroups = selector.IsResetGroupsSelected();
 201     bResetGuide = selector.IsResetGuideSelected();
 202     bResetProviders = selector.IsResetProvidersSelected();
 203     bResetReminders = selector.IsResetRemindersSelected();
 204     bResetRecordings = selector.IsResetRecordingsSelected();
 205     bResetClients = selector.IsResetClientsSelected();
 206   }
 207
 208   CDateTime::ResetTimezoneBias();
 209
 210   CLog::LogFC(LOGDEBUG, LOGPVR, "PVR clearing {} database", bResetEPGOnly ? "EPG" : "PVR and EPG");
 211
 212   pDlgProgress->SetHeading(CVariant{313}); // "Cleaning database"
 213   pDlgProgress->SetLine(0, CVariant{g_localizeStrings.Get(19187)}); // "Clearing all related data."
 214   pDlgProgress->SetLine(1, CVariant{""});
 215   pDlgProgress->SetLine(2, CVariant{""});
 216
 217   pDlgProgress->Open();
 218   pDlgProgress->Progress();
 219
 220   if (CServiceBroker::GetPVRManager().PlaybackState()->IsPlaying())
 221   {
 222     CLog::Log(LOGINFO, "PVR is stopping playback for {} database reset",
 223               bResetEPGOnly ? "EPG" : "PVR and EPG");
 224     CServiceBroker::GetAppMessenger()->SendMsg(TMSG_MEDIA_STOP);
 225   }
 226
 227   const std::shared_ptr<CPVRDatabase> pvrDatabase(CServiceBroker::GetPVRManager().GetTVDatabase());
 228   const std::shared_ptr<CPVREpgDatabase> epgDatabase(
 229       CServiceBroker::GetPVRManager().EpgContainer().GetEpgDatabase());
 230
 231   // increase db open refcounts, so they don't get closed during following pvr manager shutdown
 232   pvrDatabase->Open();
 233   epgDatabase->Open();
 234
 235   // stop pvr manager; close both pvr and epg databases
 236   CServiceBroker::GetPVRManager().Stop();
 237
 238   const int iProgressStepPercentage =
 239       100 / ((2 * bResetChannels) + bResetGroups + bResetGuide + bResetProviders + bResetReminders +
 240              bResetRecordings + bResetClients + 1);
 241   int iProgressStepsDone = 0;
 242
 243   if (bResetProviders)
 244   {
 245     pDlgProgress->SetPercentage(iProgressStepPercentage * ++iProgressStepsDone);
 246     pDlgProgress->Progress();
 247
 248     // delete all providers
 249     pvrDatabase->DeleteProviders();
 250   }
 251
 252   if (bResetGuide)
 253   {
 254     pDlgProgress->SetPercentage(iProgressStepPercentage * ++iProgressStepsDone);
 255     pDlgProgress->Progress();
 256
 257     // reset channel's EPG pointers
 258     pvrDatabase->ResetEPG();
 259
 260     // delete all entries from the EPG database
 261     epgDatabase->DeleteEpg();
 262   }
 263
 264   if (bResetGroups)
 265   {
 266     pDlgProgress->SetPercentage(iProgressStepPercentage * ++iProgressStepsDone);
 267     pDlgProgress->Progress();
 268
 269     // delete all channel groups (including data only available locally, like user defined groups)
 270     pvrDatabase->DeleteChannelGroups();
 271   }
 272
 273   if (bResetChannels)
 274   {
 275     pDlgProgress->SetPercentage(iProgressStepPercentage * ++iProgressStepsDone);
 276     pDlgProgress->Progress();
 277
 278     // delete all channels (including data only available locally, like user set icons)
 279     pvrDatabase->DeleteChannels();
 280   }
 281
 282   if (bResetReminders)
 283   {
 284     pDlgProgress->SetPercentage(iProgressStepPercentage * ++iProgressStepsDone);
 285     pDlgProgress->Progress();
 286
 287     // delete all timers data (e.g. all reminders, which are only stored locally)
 288     pvrDatabase->DeleteTimers();
 289   }
 290
 291   if (bResetClients)
 292   {
 293     pDlgProgress->SetPercentage(iProgressStepPercentage * ++iProgressStepsDone);
 294     pDlgProgress->Progress();
 295
 296     // delete all clients data (e.g priorities, which are only stored locally)
 297     pvrDatabase->DeleteClients();
 298   }
 299
 300   if (bResetChannels || bResetRecordings)
 301   {
 302     CVideoDatabase videoDatabase;
 303
 304     if (videoDatabase.Open())
 305     {
 306       if (bResetChannels)
 307       {
 308         pDlgProgress->SetPercentage(iProgressStepPercentage * ++iProgressStepsDone);
 309         pDlgProgress->Progress();
 310
 311         // delete all channel's entries (e.g. settings, bookmarks, stream details)
 312         videoDatabase.EraseAllForPath("pvr://channels/");
 313       }
 314
 315       if (bResetRecordings)
 316       {
 317         pDlgProgress->SetPercentage(iProgressStepPercentage * ++iProgressStepsDone);
 318         pDlgProgress->Progress();
 319
 320         // delete all recording's entries (e.g. settings, bookmarks, stream details)
 321         videoDatabase.EraseAllForPath(CPVRRecordingsPath::PATH_RECORDINGS);
 322       }
 323
 324       videoDatabase.Close();
 325     }
 326   }
 327
 328   // decrease db open refcounts; this actually closes dbs because refcounts drops to zero
 329   pvrDatabase->Close();
 330   epgDatabase->Close();
 331
 332   CLog::LogFC(LOGDEBUG, LOGPVR, "{} database cleared", bResetEPGOnly ? "EPG" : "PVR and EPG");
 333
 334   CLog::Log(LOGINFO, "Restarting the PVR Manager after {} database reset",
 335             bResetEPGOnly ? "EPG" : "PVR and EPG");
 336   CServiceBroker::GetPVRManager().Start();
 337
 338   pDlgProgress->SetPercentage(100);
 339   pDlgProgress->Close();
 340   return true;
 341 }