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