xbmc/pvr/windows/GUIWindowPVRSearch.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 "GUIWindowPVRSearch.h"
  10
  11 #include "FileItem.h"
  12 #include "FileItemList.h"
  13 #include "ServiceBroker.h"
  14 #include "dialogs/GUIDialogBusy.h"
  15 #include "dialogs/GUIDialogYesNo.h"
  16 #include "guilib/GUIComponent.h"
  17 #include "guilib/GUIMessage.h"
  18 #include "guilib/GUIWindowManager.h"
  19 #include "guilib/LocalizeStrings.h"
  20 #include "input/actions/Action.h"
  21 #include "input/actions/ActionIDs.h"
  22 #include "messaging/helpers/DialogOKHelper.h"
  23 #include "pvr/PVRItem.h"
  24 #include "pvr/PVRManager.h"
  25 #include "pvr/dialogs/GUIDialogPVRGuideSearch.h"
  26 #include "pvr/epg/Epg.h"
  27 #include "pvr/epg/EpgContainer.h"
  28 #include "pvr/epg/EpgInfoTag.h"
  29 #include "pvr/epg/EpgSearchFilter.h"
  30 #include "pvr/epg/EpgSearchPath.h"
  31 #include "pvr/guilib/PVRGUIActionsEPG.h"
  32 #include "pvr/guilib/PVRGUIActionsTimers.h"
  33 #include "pvr/recordings/PVRRecording.h"
  34 #include "threads/IRunnable.h"
  35 #include "utils/StringUtils.h"
  36 #include "utils/URIUtils.h"
  37 #include "utils/Variant.h"
  38
  39 #include <algorithm>
  40 #include <memory>
  41 #include <vector>
  42
  43 using namespace PVR;
  44 using namespace KODI::MESSAGING;
  45
  46 namespace
  47 {
  48 class AsyncSearchAction : private IRunnable
  49 {
  50 public:
  51   AsyncSearchAction() = delete;
  52   AsyncSearchAction(CFileItemList* items, CPVREpgSearchFilter* filter)
  53     : m_items(items), m_filter(filter)
  54   {
  55   }
  56   bool Execute();
  57
  58 private:
  59   // IRunnable implementation
  60   void Run() override;
  61
  62   CFileItemList* m_items;
  63   CPVREpgSearchFilter* m_filter;
  64 };
  65
  66 bool AsyncSearchAction::Execute()
  67 {
  68   CGUIDialogBusy::Wait(this, 100, false);
  69   return true;
  70 }
  71
  72 void AsyncSearchAction::Run()
  73 {
  74   std::vector<std::shared_ptr<CPVREpgInfoTag>> results =
  75       CServiceBroker::GetPVRManager().EpgContainer().GetTags(m_filter->GetEpgSearchData());
  76   m_filter->SetEpgSearchDataFiltered();
  77
  78   // Tags can still contain false positives, for search criteria that cannot be handled via
  79   // database. So, run extended search filters on what we got from the database.
  80   for (auto it = results.begin(); it != results.end();)
  81   {
  82     it = results.erase(std::remove_if(results.begin(), results.end(),
  83                                       [this](const std::shared_ptr<CPVREpgInfoTag>& entry) {
  84                                         return !m_filter->FilterEntry(entry);
  85                                       }),
  86                        results.end());
  87   }
  88
  89   if (m_filter->ShouldRemoveDuplicates())
  90     m_filter->RemoveDuplicates(results);
  91
  92   m_filter->SetLastExecutedDateTime(CDateTime::GetUTCDateTime());
  93
  94   for (const auto& tag : results)
  95   {
  96     m_items->Add(std::make_shared<CFileItem>(tag));
  97   }
  98 }
  99 } // unnamed namespace
 100
 101 CGUIWindowPVRSearchBase::CGUIWindowPVRSearchBase(bool bRadio, int id, const std::string& xmlFile)
 102   : CGUIWindowPVRBase(bRadio, id, xmlFile)
 103 {
 104 }
 105
 106 CGUIWindowPVRSearchBase::~CGUIWindowPVRSearchBase()
 107 {
 108 }
 109
 110 void CGUIWindowPVRSearchBase::GetContextButtons(int itemNumber, CContextButtons& buttons)
 111 {
 112   if (itemNumber < 0 || itemNumber >= m_vecItems->Size())
 113     return;
 114
 115   const CPVREpgSearchPath path(m_vecItems->GetPath());
 116   const bool bIsSavedSearchesRoot = (path.IsValid() && path.IsSavedSearchesRoot());
 117   if (!bIsSavedSearchesRoot)
 118     buttons.Add(CONTEXT_BUTTON_CLEAR, 19232); // "Clear search results"
 119
 120   CGUIWindowPVRBase::GetContextButtons(itemNumber, buttons);
 121 }
 122
 123 bool CGUIWindowPVRSearchBase::OnContextButton(int itemNumber, CONTEXT_BUTTON button)
 124 {
 125   if (itemNumber < 0 || itemNumber >= m_vecItems->Size())
 126     return false;
 127   CFileItemPtr pItem = m_vecItems->Get(itemNumber);
 128
 129   return OnContextButtonClear(pItem.get(), button) ||
 130          CGUIMediaWindow::OnContextButton(itemNumber, button);
 131 }
 132
 133 void CGUIWindowPVRSearchBase::SetItemToSearch(const CFileItem& item)
 134 {
 135   if (item.HasEPGSearchFilter())
 136   {
 137     SetSearchFilter(item.GetEPGSearchFilter());
 138   }
 139   else if (item.IsUsablePVRRecording())
 140   {
 141     SetSearchFilter(std::make_shared<CPVREpgSearchFilter>(m_bRadio));
 142     m_searchfilter->SetSearchPhrase(item.GetPVRRecordingInfoTag()->m_strTitle);
 143   }
 144   else
 145   {
 146     SetSearchFilter(std::make_shared<CPVREpgSearchFilter>(m_bRadio));
 147
 148     const std::shared_ptr<const CPVREpgInfoTag> epgTag(CPVRItem(item).GetEpgInfoTag());
 149     if (epgTag && !CServiceBroker::GetPVRManager().IsParentalLocked(epgTag))
 150       m_searchfilter->SetSearchPhrase(epgTag->Title());
 151   }
 152
 153   ExecuteSearch();
 154 }
 155
 156 void CGUIWindowPVRSearchBase::OnPrepareFileItems(CFileItemList& items)
 157 {
 158   if (m_bSearchConfirmed)
 159   {
 160     items.Clear();
 161   }
 162
 163   if (items.IsEmpty())
 164   {
 165     auto item = std::make_shared<CFileItem>(CPVREpgSearchPath::PATH_SEARCH_DIALOG, false);
 166     item->SetLabel(g_localizeStrings.Get(
 167         m_searchfilter == nullptr ? 19335 : 19336)); // "New search..." / "Edit search..."
 168     item->SetLabelPreformatted(true);
 169     item->SetSpecialSort(SortSpecialOnTop);
 170     item->SetArt("icon", "DefaultPVRSearch.png");
 171     items.Add(item);
 172
 173     item = std::make_shared<CFileItem>(m_bRadio ? CPVREpgSearchPath::PATH_RADIO_SAVEDSEARCHES
 174                                                 : CPVREpgSearchPath::PATH_TV_SAVEDSEARCHES,
 175                                        true);
 176     item->SetLabel(g_localizeStrings.Get(19337)); // "Saved searches"
 177     item->SetLabelPreformatted(true);
 178     item->SetSpecialSort(SortSpecialOnTop);
 179     item->SetArt("icon", "DefaultFolder.png");
 180     items.Add(item);
 181   }
 182
 183   if (m_bSearchConfirmed)
 184   {
 185     const int itemCount = items.GetObjectCount();
 186
 187     AsyncSearchAction(&items, m_searchfilter.get()).Execute();
 188
 189     if (items.GetObjectCount() == itemCount)
 190     {
 191       HELPERS::ShowOKDialogText(CVariant{284}, // "No results found"
 192                                 m_searchfilter->GetSearchTerm());
 193     }
 194   }
 195 }
 196
 197 bool CGUIWindowPVRSearchBase::OnAction(const CAction& action)
 198 {
 199   if (action.GetID() == ACTION_PARENT_DIR || action.GetID() == ACTION_NAV_BACK)
 200   {
 201     const CPVREpgSearchPath path(m_vecItems->GetPath());
 202     if (path.IsValid() && path.IsSavedSearchesRoot())
 203     {
 204       // Go to root dir and show previous search results if any
 205       m_bSearchConfirmed = (m_searchfilter != nullptr);
 206       GoParentFolder();
 207       return true;
 208     }
 209   }
 210   return CGUIWindowPVRBase::OnAction(action);
 211 }
 212
 213 bool CGUIWindowPVRSearchBase::OnMessage(CGUIMessage& message)
 214 {
 215   if (message.GetMessage() == GUI_MSG_CLICKED)
 216   {
 217     if (message.GetSenderId() == m_viewControl.GetCurrentControl())
 218     {
 219       int iItem = m_viewControl.GetSelectedItem();
 220       if (iItem >= 0 && iItem < m_vecItems->Size())
 221       {
 222         CFileItemPtr pItem = m_vecItems->Get(iItem);
 223
 224         /* process actions */
 225         switch (message.GetParam1())
 226         {
 227           case ACTION_SHOW_INFO:
 228           case ACTION_SELECT_ITEM:
 229           case ACTION_MOUSE_LEFT_CLICK:
 230           {
 231             const CPVREpgSearchPath path(pItem->GetPath());
 232             const bool bIsSavedSearch = (path.IsValid() && path.IsSavedSearch());
 233             const bool bIsSavedSearchesRoot = (path.IsValid() && path.IsSavedSearchesRoot());
 234
 235             if (message.GetParam1() != ACTION_SHOW_INFO)
 236             {
 237               if (pItem->IsParentFolder())
 238               {
 239                 // Go to root dir and show previous search results if any
 240                 m_bSearchConfirmed = (m_searchfilter != nullptr);
 241                 break; // handled by base class
 242               }
 243
 244               if (bIsSavedSearchesRoot)
 245               {
 246                 // List saved searches
 247                 m_bSearchConfirmed = false;
 248                 break; // handled by base class
 249               }
 250
 251               if (bIsSavedSearch)
 252               {
 253                 // Execute selected saved search
 254                 SetSearchFilter(pItem->GetEPGSearchFilter());
 255                 ExecuteSearch();
 256                 return true;
 257               }
 258             }
 259
 260             if (bIsSavedSearch)
 261             {
 262               OpenDialogSearch(*pItem);
 263             }
 264             else if (pItem->GetPath() == CPVREpgSearchPath::PATH_SEARCH_DIALOG)
 265             {
 266               OpenDialogSearch(m_searchfilter);
 267             }
 268             else
 269             {
 270               CServiceBroker::GetPVRManager().Get<PVR::GUI::EPG>().ShowEPGInfo(*pItem);
 271             }
 272             return true;
 273           }
 274
 275           case ACTION_CONTEXT_MENU:
 276           case ACTION_MOUSE_RIGHT_CLICK:
 277             OnPopupMenu(iItem);
 278             return true;
 279
 280           case ACTION_RECORD:
 281             CServiceBroker::GetPVRManager().Get<PVR::GUI::Timers>().ToggleTimer(*pItem);
 282             return true;
 283         }
 284       }
 285     }
 286   }
 287   else if (message.GetMessage() == GUI_MSG_REFRESH_LIST)
 288   {
 289     if (static_cast<PVREvent>(message.GetParam1()) == PVREvent::SavedSearchesInvalidated)
 290     {
 291       Refresh(true);
 292
 293       // Refresh triggered by deleted saved search?
 294       if (m_searchfilter)
 295       {
 296         const CPVREpgSearchPath path(m_vecItems->GetPath());
 297         const bool bIsSavedSearchesRoot = (path.IsValid() && path.IsSavedSearchesRoot());
 298         if (bIsSavedSearchesRoot)
 299         {
 300           const std::string filterPath = m_searchfilter->GetPath();
 301           bool bFound = false;
 302           for (const auto& item : *m_vecItems)
 303           {
 304             const auto filter = item->GetEPGSearchFilter();
 305             if (filter && filter->GetPath() == filterPath)
 306             {
 307               bFound = true;
 308               break;
 309             }
 310           }
 311           if (!bFound)
 312             SetSearchFilter(nullptr);
 313         }
 314       }
 315     }
 316   }
 317   else if (message.GetMessage() == GUI_MSG_WINDOW_INIT)
 318   {
 319     const CPVREpgSearchPath path(message.GetStringParam(0));
 320     if (path.IsValid() && path.IsSavedSearch())
 321     {
 322       const std::shared_ptr<CPVREpgSearchFilter> filter =
 323           CServiceBroker::GetPVRManager().EpgContainer().GetSavedSearchById(path.IsRadio(),
 324                                                                             path.GetId());
 325       if (filter)
 326       {
 327         SetSearchFilter(filter);
 328         m_bSearchConfirmed = true;
 329       }
 330     }
 331   }
 332
 333   return CGUIWindowPVRBase::OnMessage(message);
 334 }
 335
 336 bool CGUIWindowPVRSearchBase::Update(const std::string& strDirectory,
 337                                      bool updateFilterPath /* = true */)
 338 {
 339   if (m_vecItems->GetObjectCount() > 0)
 340   {
 341     const CPVREpgSearchPath path(m_vecItems->GetPath());
 342     if (path.IsValid() && path.IsSavedSearchesRoot())
 343     {
 344       const std::string oldPath = m_vecItems->GetPath();
 345
 346       const bool bReturn = CGUIWindowPVRBase::Update(strDirectory);
 347
 348       if (bReturn && oldPath == m_vecItems->GetPath() && m_vecItems->GetObjectCount() == 0)
 349       {
 350         // Go to parent folder if we're in a subdir and for instance just deleted the last item
 351         GoParentFolder();
 352       }
 353       return bReturn;
 354     }
 355   }
 356   return CGUIWindowPVRBase::Update(strDirectory);
 357 }
 358
 359 void CGUIWindowPVRSearchBase::UpdateButtons()
 360 {
 361   CGUIWindowPVRBase::UpdateButtons();
 362
 363   bool bSavedSearchesRoot = false;
 364   std::string header;
 365   const CPVREpgSearchPath path(m_vecItems->GetPath());
 366   if (path.IsValid() && path.IsSavedSearchesRoot())
 367   {
 368     bSavedSearchesRoot = true;
 369     header = g_localizeStrings.Get(19337); // "Saved searches"
 370   }
 371
 372   if (header.empty() && m_searchfilter)
 373   {
 374     header = m_searchfilter->GetTitle();
 375     if (header.empty())
 376     {
 377       header = m_searchfilter->GetSearchTerm();
 378       StringUtils::Trim(header, "\"");
 379     }
 380   }
 381   SET_CONTROL_LABEL(CONTROL_LABEL_HEADER1, header);
 382
 383   if (!bSavedSearchesRoot && m_searchfilter && m_searchfilter->IsChanged())
 384     SET_CONTROL_LABEL(CONTROL_LABEL_HEADER2, g_localizeStrings.Get(19342)); // "[not saved]"
 385   else if (!bSavedSearchesRoot && m_searchfilter)
 386     SET_CONTROL_LABEL(CONTROL_LABEL_HEADER2, g_localizeStrings.Get(19343)); // "[saved]"
 387   else
 388     SET_CONTROL_LABEL(CONTROL_LABEL_HEADER2, "");
 389 }
 390
 391 bool CGUIWindowPVRSearchBase::OnContextButtonClear(CFileItem* item, CONTEXT_BUTTON button)
 392 {
 393   bool bReturn = false;
 394
 395   if (button == CONTEXT_BUTTON_CLEAR)
 396   {
 397     bReturn = true;
 398
 399     m_bSearchConfirmed = false;
 400     SetSearchFilter(nullptr);
 401
 402     Refresh(true);
 403   }
 404
 405   return bReturn;
 406 }
 407
 408 CGUIDialogPVRGuideSearch::Result CGUIWindowPVRSearchBase::OpenDialogSearch(const CFileItem& item)
 409 {
 410   const auto searchFilter = item.GetEPGSearchFilter();
 411   if (!searchFilter)
 412     return CGUIDialogPVRGuideSearch::Result::CANCEL;
 413
 414   return OpenDialogSearch(searchFilter);
 415 }
 416
 417 CGUIDialogPVRGuideSearch::Result CGUIWindowPVRSearchBase::OpenDialogSearch(
 418     const std::shared_ptr<CPVREpgSearchFilter>& searchFilter)
 419 {
 420   CGUIDialogPVRGuideSearch* dlgSearch =
 421       CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogPVRGuideSearch>(
 422           WINDOW_DIALOG_PVR_GUIDE_SEARCH);
 423
 424   if (!dlgSearch)
 425     return CGUIDialogPVRGuideSearch::Result::CANCEL;
 426
 427   const std::shared_ptr<CPVREpgSearchFilter> tmpSearchFilter =
 428       searchFilter != nullptr ? std::make_shared<CPVREpgSearchFilter>(*searchFilter)
 429                               : std::make_shared<CPVREpgSearchFilter>(m_bRadio);
 430
 431   dlgSearch->SetFilterData(tmpSearchFilter);
 432
 433   /* Open dialog window */
 434   dlgSearch->Open();
 435
 436   const CGUIDialogPVRGuideSearch::Result result = dlgSearch->GetResult();
 437   if (result == CGUIDialogPVRGuideSearch::Result::SEARCH)
 438   {
 439     SetSearchFilter(tmpSearchFilter);
 440     ExecuteSearch();
 441   }
 442   else if (result == CGUIDialogPVRGuideSearch::Result::SAVE)
 443   {
 444     CServiceBroker::GetPVRManager().EpgContainer().PersistSavedSearch(*tmpSearchFilter);
 445     if (searchFilter)
 446       searchFilter->SetDatabaseId(tmpSearchFilter->GetDatabaseId());
 447
 448     const CPVREpgSearchPath path(m_vecItems->GetPath());
 449     if (path.IsValid() && path.IsSearchRoot())
 450     {
 451       SetSearchFilter(tmpSearchFilter);
 452       ExecuteSearch();
 453     }
 454   }
 455
 456   return result;
 457 }
 458
 459 void CGUIWindowPVRSearchBase::ExecuteSearch()
 460 {
 461   m_bSearchConfirmed = true;
 462
 463   const CPVREpgSearchPath path(m_vecItems->GetPath());
 464   if (path.IsValid() && path.IsSavedSearchesRoot())
 465   {
 466     GoParentFolder();
 467   }
 468   else if (IsActive())
 469   {
 470     Refresh(true);
 471   }
 472
 473   // Save if not a transient search
 474   if (m_searchfilter->GetDatabaseId() != -1)
 475     CServiceBroker::GetPVRManager().EpgContainer().UpdateSavedSearchLastExecuted(*m_searchfilter);
 476 }
 477
 478 void CGUIWindowPVRSearchBase::SetSearchFilter(
 479     const std::shared_ptr<CPVREpgSearchFilter>& searchFilter)
 480 {
 481   if (m_searchfilter && m_searchfilter->IsChanged() &&
 482       (!searchFilter || m_searchfilter->GetPath() != searchFilter->GetPath()))
 483   {
 484     bool bCanceled = false;
 485     if (!CGUIDialogYesNo::ShowAndGetInput(CVariant{14117}, // "Warning"
 486                                           CVariant{19341}, // "Save the current search?"
 487                                           CVariant{},
 488                                           CVariant{!m_searchfilter->GetTitle().empty()
 489                                                        ? m_searchfilter->GetTitle()
 490                                                        : m_searchfilter->GetSearchTerm()},
 491                                           bCanceled, CVariant{107}, // "Yes"
 492                                           CVariant{106}, // "No"
 493                                           CGUIDialogYesNo::NO_TIMEOUT) &&
 494         !bCanceled)
 495     {
 496       std::string title = m_searchfilter->GetTitle();
 497       if (title.empty())
 498       {
 499         title = m_searchfilter->GetSearchTerm();
 500         if (title.empty())
 501           title = g_localizeStrings.Get(137); // "Search"
 502         else
 503           StringUtils::Trim(title, "\"");
 504
 505         m_searchfilter->SetTitle(title);
 506       }
 507       CServiceBroker::GetPVRManager().EpgContainer().PersistSavedSearch(*m_searchfilter);
 508     }
 509   }
 510   m_searchfilter = searchFilter;
 511 }
 512
 513 std::string CGUIWindowPVRTVSearch::GetRootPath() const
 514 {
 515   return CPVREpgSearchPath::PATH_TV_SEARCH;
 516 }
 517
 518 std::string CGUIWindowPVRTVSearch::GetStartFolder(const std::string& dir)
 519 {
 520   return CPVREpgSearchPath::PATH_TV_SEARCH;
 521 }
 522
 523 std::string CGUIWindowPVRTVSearch::GetDirectoryPath()
 524 {
 525   return URIUtils::PathHasParent(m_vecItems->GetPath(), CPVREpgSearchPath::PATH_TV_SEARCH)
 526              ? m_vecItems->GetPath()
 527              : CPVREpgSearchPath::PATH_TV_SEARCH;
 528 }
 529
 530 std::string CGUIWindowPVRRadioSearch::GetRootPath() const
 531 {
 532   return CPVREpgSearchPath::PATH_RADIO_SEARCH;
 533 }
 534
 535 std::string CGUIWindowPVRRadioSearch::GetStartFolder(const std::string& dir)
 536 {
 537   return CPVREpgSearchPath::PATH_RADIO_SEARCH;
 538 }
 539
 540 std::string CGUIWindowPVRRadioSearch::GetDirectoryPath()
 541 {
 542   return URIUtils::PathHasParent(m_vecItems->GetPath(), CPVREpgSearchPath::PATH_RADIO_SEARCH)
 543              ? m_vecItems->GetPath()
 544              : CPVREpgSearchPath::PATH_RADIO_SEARCH;
 545 }