xbmc/favourites/GUIWindowFavourites.cpp

   1 /*
   2  *  Copyright (C) 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 "GUIWindowFavourites.h"
  10
  11 #include "ContextMenuManager.h"
  12 #include "FileItem.h"
  13 #include "ServiceBroker.h"
  14 #include "favourites/FavouritesURL.h"
  15 #include "favourites/FavouritesUtils.h"
  16 #include "guilib/GUIComponent.h"
  17 #include "guilib/GUIMessage.h"
  18 #include "guilib/GUIWindowManager.h"
  19 #include "input/actions/Action.h"
  20 #include "input/actions/ActionIDs.h"
  21 #include "messaging/ApplicationMessenger.h"
  22 #include "utils/PlayerUtils.h"
  23 #include "utils/StringUtils.h"
  24 #include "utils/guilib/GUIContentUtils.h"
  25 #include "video/VideoUtils.h"
  26 #include "video/guilib/VideoGUIUtils.h"
  27 #include "video/guilib/VideoPlayActionProcessor.h"
  28 #include "video/guilib/VideoSelectActionProcessor.h"
  29
  30 using namespace KODI;
  31
  32 CGUIWindowFavourites::CGUIWindowFavourites()
  33   : CGUIMediaWindow(WINDOW_FAVOURITES, "MyFavourites.xml")
  34 {
  35   m_loadType = KEEP_IN_MEMORY;
  36   CServiceBroker::GetFavouritesService().Events().Subscribe(
  37       this, &CGUIWindowFavourites::OnFavouritesEvent);
  38 }
  39
  40 CGUIWindowFavourites::~CGUIWindowFavourites()
  41 {
  42   CServiceBroker::GetFavouritesService().Events().Unsubscribe(this);
  43 }
  44
  45 void CGUIWindowFavourites::OnFavouritesEvent(const CFavouritesService::FavouritesUpdated& event)
  46 {
  47   CGUIMessage m(GUI_MSG_REFRESH_LIST, GetID(), 0, 0);
  48   CServiceBroker::GetAppMessenger()->SendGUIMessage(m);
  49 }
  50
  51 namespace
  52 {
  53 class CVideoSelectActionProcessor : public VIDEO::GUILIB::CVideoSelectActionProcessorBase
  54 {
  55 public:
  56   explicit CVideoSelectActionProcessor(const std::shared_ptr<CFileItem>& item)
  57     : CVideoSelectActionProcessorBase(item)
  58   {
  59   }
  60
  61 protected:
  62   bool OnPlayPartSelected(unsigned int part) override
  63   {
  64     // part numbers are 1-based
  65     FAVOURITES_UTILS::ExecuteAction(
  66         {"PlayMedia", *m_item, StringUtils::Format("playoffset={}", part - 1)});
  67     return true;
  68   }
  69
  70   bool OnResumeSelected() override
  71   {
  72     FAVOURITES_UTILS::ExecuteAction({"PlayMedia", *m_item, "resume"});
  73     return true;
  74   }
  75
  76   bool OnPlaySelected() override
  77   {
  78     FAVOURITES_UTILS::ExecuteAction({"PlayMedia", *m_item, "noresume"});
  79     return true;
  80   }
  81
  82   bool OnQueueSelected() override
  83   {
  84     FAVOURITES_UTILS::ExecuteAction({"QueueMedia", *m_item, ""});
  85     return true;
  86   }
  87
  88   bool OnInfoSelected() override
  89   {
  90     return UTILS::GUILIB::CGUIContentUtils::ShowInfoForItem(*m_item);
  91   }
  92
  93   bool OnMoreSelected() override
  94   {
  95     CONTEXTMENU::ShowFor(m_item, CContextMenuManager::MAIN);
  96     return true;
  97   }
  98 };
  99
 100 class CVideoPlayActionProcessor : public VIDEO::GUILIB::CVideoPlayActionProcessorBase
 101 {
 102 public:
 103   explicit CVideoPlayActionProcessor(const ::std::shared_ptr<CFileItem>& item)
 104     : CVideoPlayActionProcessorBase(item)
 105   {
 106   }
 107
 108 protected:
 109   bool OnResumeSelected() override
 110   {
 111     FAVOURITES_UTILS::ExecuteAction({"PlayMedia", *m_item, "resume"});
 112     return true;
 113   }
 114
 115   bool OnPlaySelected() override
 116   {
 117     FAVOURITES_UTILS::ExecuteAction({"PlayMedia", *m_item, "noresume"});
 118     return true;
 119   }
 120 };
 121 } // namespace
 122
 123 bool CGUIWindowFavourites::OnSelect(int itemIdx)
 124 {
 125   if (itemIdx < 0 || itemIdx >= m_vecItems->Size())
 126     return false;
 127
 128   const auto item{(*m_vecItems)[itemIdx]};
 129   const CFavouritesURL favURL{*item, GetID()};
 130   if (!favURL.IsValid())
 131     return false;
 132
 133   const bool isPlayMedia{favURL.GetAction() == CFavouritesURL::Action::PLAY_MEDIA};
 134
 135   const auto target{CServiceBroker::GetFavouritesService().ResolveFavourite(*item)};
 136   if (!target)
 137     return false;
 138
 139   CFileItem targetItem{*target};
 140
 141   // video select action setting is for files only, except exec func is playmedia...
 142   if (targetItem.HasVideoInfoTag() && (!targetItem.m_bIsFolder || isPlayMedia))
 143   {
 144     // play the given/default video version, even if multiple versions are available
 145     targetItem.SetProperty("has_resolved_video_asset", true);
 146
 147     CVideoSelectActionProcessor proc{std::make_shared<CFileItem>(targetItem)};
 148     if (proc.ProcessDefaultAction())
 149       return true;
 150   }
 151
 152   // exec the execute string for the original (!) item
 153   return FAVOURITES_UTILS::ExecuteAction(favURL);
 154 }
 155
 156 bool CGUIWindowFavourites::OnAction(const CAction& action)
 157 {
 158   const int selectedItem = m_viewControl.GetSelectedItem();
 159   if (selectedItem < 0 || selectedItem >= m_vecItems->Size())
 160     return false;
 161
 162   if (action.GetID() == ACTION_PLAYER_PLAY)
 163   {
 164     const auto target{
 165         CServiceBroker::GetFavouritesService().ResolveFavourite(*(*m_vecItems)[selectedItem])};
 166     if (!target)
 167       return false;
 168
 169     const auto item{std::make_shared<CFileItem>(*target)};
 170
 171     // video play action setting is for files and folders...
 172     if (item->HasVideoInfoTag() || (item->m_bIsFolder && VIDEO::UTILS::IsItemPlayable(*item)))
 173     {
 174       CVideoPlayActionProcessor proc{item};
 175       if (proc.ProcessDefaultAction())
 176         return true;
 177     }
 178
 179     if (CPlayerUtils::IsItemPlayable(*item))
 180     {
 181       CFavouritesURL target{*item, {}};
 182       if (target.GetAction() != CFavouritesURL::Action::PLAY_MEDIA)
 183       {
 184         // build a playmedia execute string for given target
 185         target = CFavouritesURL{CFavouritesURL::Action::PLAY_MEDIA,
 186                                 {StringUtils::Paramify(item->GetPath())}};
 187       }
 188       return FAVOURITES_UTILS::ExecuteAction(target);
 189     }
 190     return false;
 191   }
 192   else if (action.GetID() == ACTION_SHOW_INFO)
 193   {
 194     const auto targetItem{
 195         CServiceBroker::GetFavouritesService().ResolveFavourite(*(*m_vecItems)[selectedItem])};
 196
 197     return UTILS::GUILIB::CGUIContentUtils::ShowInfoForItem(*targetItem);
 198   }
 199   else if (action.GetID() == ACTION_MOVE_ITEM_UP)
 200   {
 201     if (FAVOURITES_UTILS::ShouldEnableMoveItems())
 202       return MoveItem(selectedItem, -1);
 203   }
 204   else if (action.GetID() == ACTION_MOVE_ITEM_DOWN)
 205   {
 206     if (FAVOURITES_UTILS::ShouldEnableMoveItems())
 207       return MoveItem(selectedItem, +1);
 208   }
 209   else if (action.GetID() == ACTION_DELETE_ITEM)
 210   {
 211     return RemoveItem(selectedItem);
 212   }
 213
 214   return CGUIMediaWindow::OnAction(action);
 215 }
 216
 217 bool CGUIWindowFavourites::OnMessage(CGUIMessage& message)
 218 {
 219   bool ret = false;
 220
 221   switch (message.GetMessage())
 222   {
 223     case GUI_MSG_REFRESH_LIST:
 224     {
 225       const int size = m_vecItems->Size();
 226       int selected = m_viewControl.GetSelectedItem();
 227       if (m_vecItems->Size() > 0 && selected == size - 1)
 228         --selected; // remove of last item, select the new last item after refresh
 229
 230       Refresh(true);
 231
 232       if (m_vecItems->Size() < size)
 233       {
 234         // item removed. select item after the removed item
 235         m_viewControl.SetSelectedItem(selected);
 236       }
 237
 238       ret = true;
 239       break;
 240     }
 241   }
 242
 243   return ret || CGUIMediaWindow::OnMessage(message);
 244 }
 245
 246 bool CGUIWindowFavourites::Update(const std::string& strDirectory,
 247                                   bool updateFilterPath /* = true */)
 248 {
 249   std::string directory = strDirectory;
 250   if (directory.empty())
 251     directory = "favourites://";
 252
 253   return CGUIMediaWindow::Update(directory, updateFilterPath);
 254 }
 255
 256 bool CGUIWindowFavourites::MoveItem(int item, int amount)
 257 {
 258   if (item < 0 || item >= m_vecItems->Size() || m_vecItems->Size() < 2 || amount == 0)
 259     return false;
 260
 261   if (FAVOURITES_UTILS::MoveItem(*m_vecItems, (*m_vecItems)[item], amount) &&
 262       CServiceBroker::GetFavouritesService().Save(*m_vecItems))
 263   {
 264     int selected = item + amount;
 265     if (selected >= m_vecItems->Size())
 266       selected = 0;
 267     else if (selected < 0)
 268       selected = m_vecItems->Size() - 1;
 269
 270     m_viewControl.SetSelectedItem(selected);
 271     return true;
 272   }
 273
 274   return false;
 275 }
 276
 277 bool CGUIWindowFavourites::RemoveItem(int item)
 278 {
 279   if (item < 0 || item >= m_vecItems->Size())
 280     return false;
 281
 282   if (FAVOURITES_UTILS::RemoveItem(*m_vecItems, (*m_vecItems)[item]) &&
 283       CServiceBroker::GetFavouritesService().Save(*m_vecItems))
 284     return true;
 285
 286   return false;
 287 }