xbmc/video/dialogs/GUIDialogVideoManager.cpp

   1 /*
   2  *  Copyright (C) 2023 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 "GUIDialogVideoManager.h"
  10
  11 #include "FileItem.h"
  12 #include "FileItemList.h"
  13 #include "GUIUserMessages.h"
  14 #include "MediaSource.h"
  15 #include "ServiceBroker.h"
  16 #include "dialogs/GUIDialogOK.h"
  17 #include "dialogs/GUIDialogSelect.h"
  18 #include "dialogs/GUIDialogYesNo.h"
  19 #include "filesystem/Directory.h"
  20 #include "guilib/GUIComponent.h"
  21 #include "guilib/GUIKeyboardFactory.h"
  22 #include "guilib/GUIWindowManager.h"
  23 #include "guilib/LocalizeStrings.h"
  24 #include "input/actions/Action.h"
  25 #include "input/actions/ActionIDs.h"
  26 #include "playlists/PlayListTypes.h"
  27 #include "utils/ContentUtils.h"
  28 #include "utils/StringUtils.h"
  29 #include "utils/URIUtils.h"
  30 #include "utils/log.h"
  31 #include "video/VideoManagerTypes.h"
  32 #include "video/VideoThumbLoader.h"
  33 #include "video/dialogs/GUIDialogVideoInfo.h"
  34 #include "video/guilib/VideoGUIUtils.h"
  35 #include "video/guilib/VideoPlayActionProcessor.h"
  36
  37 #include <algorithm>
  38 #include <string>
  39
  40 using namespace KODI;
  41
  42 static constexpr unsigned int CONTROL_LABEL_TITLE = 2;
  43
  44 static constexpr unsigned int CONTROL_BUTTON_PLAY = 21;
  45 static constexpr unsigned int CONTROL_BUTTON_REMOVE = 26;
  46 static constexpr unsigned int CONTROL_BUTTON_CHOOSE_ART = 27;
  47
  48 static constexpr unsigned int CONTROL_LIST_ASSETS = 50;
  49
  50 CGUIDialogVideoManager::CGUIDialogVideoManager(int windowId)
  51   : CGUIDialog(windowId, "DialogVideoManager.xml"),
  52     m_videoAsset(std::make_shared<CFileItem>()),
  53     m_videoAssetsList(std::make_unique<CFileItemList>()),
  54     m_selectedVideoAsset(std::make_shared<CFileItem>())
  55 {
  56   m_loadType = KEEP_IN_MEMORY;
  57 }
  58
  59 bool CGUIDialogVideoManager::OnMessage(CGUIMessage& message)
  60 {
  61   switch (message.GetMessage())
  62   {
  63     case GUI_MSG_WINDOW_DEINIT:
  64     {
  65       Clear();
  66       break;
  67     }
  68
  69     case GUI_MSG_CLICKED:
  70     {
  71       const int control{message.GetSenderId()};
  72       if (control == CONTROL_LIST_ASSETS)
  73       {
  74         const int action{message.GetParam1()};
  75         if (action == ACTION_SELECT_ITEM || action == ACTION_MOUSE_LEFT_CLICK)
  76         {
  77           if (UpdateSelectedAsset())
  78             SET_CONTROL_FOCUS(CONTROL_BUTTON_PLAY, 0);
  79         }
  80       }
  81       else if (control == CONTROL_BUTTON_PLAY)
  82       {
  83         Play();
  84       }
  85       else if (control == CONTROL_BUTTON_REMOVE)
  86       {
  87         Remove();
  88       }
  89       else if (control == CONTROL_BUTTON_CHOOSE_ART)
  90       {
  91         ChooseArt();
  92       }
  93       break;
  94     }
  95   }
  96
  97   return CGUIDialog::OnMessage(message);
  98 }
  99
 100 bool CGUIDialogVideoManager::OnAction(const CAction& action)
 101 {
 102   const int actionId{action.GetID()};
 103   if (actionId == ACTION_MOVE_DOWN || actionId == ACTION_MOVE_UP || actionId == ACTION_PAGE_DOWN ||
 104       actionId == ACTION_PAGE_UP || actionId == ACTION_FIRST_PAGE || actionId == ACTION_LAST_PAGE)
 105   {
 106     if (GetFocusedControlID() == CONTROL_LIST_ASSETS)
 107     {
 108       CGUIDialog::OnAction(action);
 109       return UpdateSelectedAsset();
 110     }
 111   }
 112
 113   return CGUIDialog::OnAction(action);
 114 }
 115
 116 void CGUIDialogVideoManager::OnInitWindow()
 117 {
 118   if (!m_database.IsOpen() && !m_database.Open())
 119     CLog::LogF(LOGERROR, "Failed to open video database!");
 120
 121   CGUIDialog::OnInitWindow();
 122
 123   SET_CONTROL_LABEL(CONTROL_LABEL_TITLE,
 124                     StringUtils::Format(g_localizeStrings.Get(GetHeadingId()),
 125                                         m_videoAsset->GetVideoInfoTag()->GetTitle()));
 126
 127   CGUIMessage msg{GUI_MSG_LABEL_BIND, GetID(), CONTROL_LIST_ASSETS, 0, 0, m_videoAssetsList.get()};
 128   OnMessage(msg);
 129
 130   UpdateControls();
 131 }
 132
 133 void CGUIDialogVideoManager::OnDeinitWindow(int nextWindowID)
 134 {
 135   CGUIDialog::OnDeinitWindow(nextWindowID);
 136   m_database.Close();
 137 }
 138
 139 void CGUIDialogVideoManager::Clear()
 140 {
 141   m_videoAssetsList->Clear();
 142 }
 143
 144 void CGUIDialogVideoManager::UpdateButtons()
 145 {
 146   // Enabled if list not empty
 147   if (!m_videoAssetsList->IsEmpty())
 148   {
 149     CONTROL_ENABLE(CONTROL_BUTTON_CHOOSE_ART);
 150     CONTROL_ENABLE(CONTROL_BUTTON_REMOVE);
 151     CONTROL_ENABLE(CONTROL_BUTTON_PLAY);
 152
 153     SET_CONTROL_FOCUS(CONTROL_LIST_ASSETS, 0);
 154   }
 155   else
 156   {
 157     CONTROL_DISABLE(CONTROL_BUTTON_CHOOSE_ART);
 158     CONTROL_DISABLE(CONTROL_BUTTON_REMOVE);
 159     CONTROL_DISABLE(CONTROL_BUTTON_PLAY);
 160   }
 161 }
 162
 163 void CGUIDialogVideoManager::UpdateAssetsList()
 164 {
 165   // find new item in list and select it
 166   for (int i = 0; i < m_videoAssetsList->Size(); ++i)
 167   {
 168     if (m_videoAssetsList->Get(i)->GetVideoInfoTag()->m_iDbId ==
 169         m_selectedVideoAsset->GetVideoInfoTag()->m_iDbId)
 170     {
 171       CONTROL_SELECT_ITEM(CONTROL_LIST_ASSETS, i);
 172       break;
 173     }
 174   }
 175 }
 176
 177 bool CGUIDialogVideoManager::UpdateSelectedAsset()
 178 {
 179   CGUIMessage msg{GUI_MSG_ITEM_SELECTED, GetID(), CONTROL_LIST_ASSETS};
 180   OnMessage(msg);
 181
 182   const int item{msg.GetParam1()};
 183   if (item >= 0 && item < m_videoAssetsList->Size())
 184   {
 185     m_selectedVideoAsset = m_videoAssetsList->Get(item);
 186     UpdateControls();
 187     return true;
 188   }
 189   return false;
 190 }
 191
 192 void CGUIDialogVideoManager::DisableRemove()
 193 {
 194   CONTROL_DISABLE(CONTROL_BUTTON_REMOVE);
 195 }
 196
 197 void CGUIDialogVideoManager::EnableRemove()
 198 {
 199   CONTROL_ENABLE(CONTROL_BUTTON_REMOVE);
 200 }
 201
 202 void CGUIDialogVideoManager::UpdateControls()
 203 {
 204   UpdateButtons();
 205   UpdateAssetsList();
 206 }
 207
 208 void CGUIDialogVideoManager::Refresh()
 209 {
 210   if (!m_database.IsOpen() && !m_database.Open())
 211     CLog::LogF(LOGERROR, "Failed to open video database!");
 212
 213   Clear();
 214
 215   const int dbId{m_videoAsset->GetVideoInfoTag()->m_iDbId};
 216   const MediaType mediaType{m_videoAsset->GetVideoInfoTag()->m_type};
 217   const VideoDbContentType itemType{m_videoAsset->GetVideoContentType()};
 218
 219   //! @todo db refactor: should not be versions, but assets
 220   m_database.GetVideoVersions(itemType, dbId, *m_videoAssetsList, GetVideoAssetType());
 221   m_videoAssetsList->SetContent(CMediaTypes::ToPlural(mediaType));
 222
 223   CVideoThumbLoader loader;
 224
 225   for (auto& item : *m_videoAssetsList)
 226   {
 227     item->SetProperty("noartfallbacktoowner", true);
 228     loader.LoadItem(item.get());
 229   }
 230
 231   CGUIMessage msg{GUI_MSG_LABEL_BIND, GetID(), CONTROL_LIST_ASSETS, 0, 0, m_videoAssetsList.get()};
 232   OnMessage(msg);
 233 }
 234
 235 void CGUIDialogVideoManager::SetVideoAsset(const std::shared_ptr<CFileItem>& item)
 236 {
 237   if (!item || !item->HasVideoInfoTag() || item->GetVideoInfoTag()->m_type != MediaTypeMovie)
 238   {
 239     CLog::LogF(LOGERROR, "Unexpected video item!");
 240     return;
 241   }
 242
 243   m_videoAsset = item;
 244
 245   Refresh();
 246 }
 247
 248 void CGUIDialogVideoManager::CloseAll()
 249 {
 250   // close our dialog
 251   Close(true);
 252
 253   // close the video info dialog if exists
 254   CGUIDialogVideoInfo* dialog{
 255       CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogVideoInfo>(
 256           WINDOW_DIALOG_VIDEO_INFO)};
 257   if (dialog)
 258     dialog->Close(true);
 259 }
 260
 261 namespace
 262 {
 263 class CVideoPlayActionProcessor : public VIDEO::GUILIB::CVideoPlayActionProcessorBase
 264 {
 265 public:
 266   explicit CVideoPlayActionProcessor(const std::shared_ptr<CFileItem>& item)
 267     : CVideoPlayActionProcessorBase(item)
 268   {
 269   }
 270
 271 protected:
 272   bool OnResumeSelected() override
 273   {
 274     m_item->SetStartOffset(STARTOFFSET_RESUME);
 275     Play();
 276     return true;
 277   }
 278
 279   bool OnPlaySelected() override
 280   {
 281     Play();
 282     return true;
 283   }
 284
 285 private:
 286   void Play()
 287   {
 288     m_item->SetProperty("playlist_type_hint", static_cast<int>(PLAYLIST::Id::TYPE_VIDEO));
 289     const ContentUtils::PlayMode mode{m_item->GetProperty("CheckAutoPlayNextItem").asBoolean()
 290                                           ? ContentUtils::PlayMode::CHECK_AUTO_PLAY_NEXT_ITEM
 291                                           : ContentUtils::PlayMode::PLAY_ONLY_THIS};
 292     VIDEO::UTILS::PlayItem(m_item, "", mode);
 293   }
 294 };
 295 } // unnamed namespace
 296
 297 void CGUIDialogVideoManager::Play()
 298 {
 299   CloseAll();
 300
 301   CVideoPlayActionProcessor proc{m_selectedVideoAsset};
 302   proc.ProcessDefaultAction();
 303 }
 304
 305 void CGUIDialogVideoManager::Remove()
 306 {
 307   // confirm to remove
 308   if (!CGUIDialogYesNo::ShowAndGetInput(
 309           CVariant(40018),
 310           StringUtils::Format(g_localizeStrings.Get(40020),
 311                               m_selectedVideoAsset->GetVideoInfoTag()->GetAssetInfo().GetTitle())))
 312   {
 313     return;
 314   }
 315
 316   m_database.DeleteVideoAsset(m_selectedVideoAsset->GetVideoInfoTag()->m_iDbId);
 317
 318   // refresh data and controls
 319   Refresh();
 320   RefreshSelectedVideoAsset();
 321   UpdateControls();
 322 }
 323
 324 void CGUIDialogVideoManager::Rename()
 325 {
 326   const int idAsset{
 327       ChooseVideoAsset(m_videoAsset, GetVideoAssetType(), m_selectedVideoAsset->m_strTitle)};
 328   if (idAsset != -1)
 329   {
 330     //! @todo db refactor: should not be version, but asset
 331     m_database.SetVideoVersion(m_selectedVideoAsset->GetVideoInfoTag()->m_iDbId, idAsset);
 332   }
 333
 334   // refresh data and controls
 335   Refresh();
 336   UpdateControls();
 337 }
 338
 339 void CGUIDialogVideoManager::ChooseArt()
 340 {
 341   if (!CGUIDialogVideoInfo::ChooseAndManageVideoItemArtwork(m_selectedVideoAsset))
 342     return;
 343
 344   // refresh data and controls
 345   Refresh();
 346   UpdateControls();
 347 }
 348
 349 void CGUIDialogVideoManager::SetSelectedVideoAsset(const std::shared_ptr<CFileItem>& asset)
 350 {
 351   const int dbId{asset->GetVideoInfoTag()->m_iDbId};
 352   const auto it{std::find_if(m_videoAssetsList->cbegin(), m_videoAssetsList->cend(),
 353                              [dbId](const auto& entry)
 354                              { return entry->GetVideoInfoTag()->m_iDbId == dbId; })};
 355   if (it != m_videoAssetsList->cend())
 356     m_selectedVideoAsset = (*it);
 357   else
 358     CLog::LogF(LOGERROR, "Item to select not found in asset list!");
 359
 360   UpdateControls();
 361 }
 362
 363 int CGUIDialogVideoManager::ChooseVideoAsset(const std::shared_ptr<CFileItem>& item,
 364                                              VideoAssetType assetType,
 365                                              const std::string& defaultName)
 366 {
 367   if (!item || !item->HasVideoInfoTag())
 368     return -1;
 369
 370   const VideoDbContentType itemType{item->GetVideoContentType()};
 371   if (itemType != VideoDbContentType::MOVIES)
 372     return -1;
 373
 374   int dialogHeadingMsgId{};
 375   int dialogButtonMsgId{};
 376   int dialogNewHeadingMsgId{};
 377
 378   switch (assetType)
 379   {
 380     case VideoAssetType::VERSION:
 381       dialogHeadingMsgId = 40215;
 382       dialogButtonMsgId = 40216;
 383       dialogNewHeadingMsgId = 40217;
 384       break;
 385     case VideoAssetType::EXTRA:
 386       dialogHeadingMsgId = 40218;
 387       dialogButtonMsgId = 40219;
 388       dialogNewHeadingMsgId = 40220;
 389       break;
 390     default:
 391       CLog::LogF(LOGERROR, "Unknown asset type ({})", static_cast<int>(assetType));
 392       return -1;
 393   }
 394
 395   CVideoDatabase videodb;
 396   if (!videodb.Open())
 397   {
 398     CLog::LogF(LOGERROR, "Failed to open video database!");
 399     return -1;
 400   }
 401
 402   CGUIDialogSelect* dialog{CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(
 403       WINDOW_DIALOG_SELECT)};
 404   if (!dialog)
 405   {
 406     CLog::LogF(LOGERROR, "Unable to get WINDOW_DIALOG_SELECT instance!");
 407     return -1;
 408   }
 409
 410   //! @todo db refactor: should not be version, but asset
 411   CFileItemList list;
 412   videodb.GetVideoVersionTypes(itemType, assetType, list);
 413
 414   int assetId{-1};
 415   while (true)
 416   {
 417     std::string assetTitle;
 418
 419     dialog->Reset();
 420     dialog->SetItems(list);
 421     dialog->SetHeading(dialogHeadingMsgId);
 422     dialog->EnableButton(true, dialogButtonMsgId);
 423     dialog->Open();
 424
 425     if (dialog->IsButtonPressed())
 426     {
 427       // create a new asset
 428       assetTitle = defaultName;
 429       if (CGUIKeyboardFactory::ShowAndGetInput(assetTitle,
 430                                                g_localizeStrings.Get(dialogNewHeadingMsgId), false))
 431       {
 432         assetTitle = StringUtils::Trim(assetTitle);
 433         //! @todo db refactor: should not be version, but asset
 434         assetId = videodb.AddVideoVersionType(assetTitle, VideoAssetTypeOwner::USER, assetType);
 435       }
 436     }
 437     else if (dialog->IsConfirmed())
 438     {
 439       const std::shared_ptr<CFileItem> selectedItem{dialog->GetSelectedFileItem()};
 440       assetId = selectedItem->GetVideoInfoTag()->GetAssetInfo().GetId();
 441       assetTitle = selectedItem->GetVideoInfoTag()->GetAssetInfo().GetTitle();
 442     }
 443     else
 444       return -1;
 445
 446     if (assetId < 0)
 447       return -1;
 448
 449     const int dbId{item->GetVideoInfoTag()->m_iDbId};
 450
 451     //! @todo db refactor: should not be versions, but assets
 452     CFileItemList assets;
 453     videodb.GetVideoVersions(itemType, dbId, assets, assetType);
 454
 455     // the selected video asset already exists
 456     if (std::any_of(assets.cbegin(), assets.cend(),
 457                     [assetId](const std::shared_ptr<CFileItem>& asset)
 458                     { return asset->GetVideoInfoTag()->m_iDbId == assetId; }))
 459     {
 460       CGUIDialogOK::ShowAndGetInput(CVariant{40005},
 461                                     StringUtils::Format(g_localizeStrings.Get(40007), assetTitle));
 462     }
 463     else
 464       break;
 465   }
 466
 467   return assetId;
 468 }
 469
 470 void CGUIDialogVideoManager::AppendItemFolderToFileBrowserSources(
 471     std::vector<CMediaSource>& sources)
 472 {
 473   const std::string itemDir{URIUtils::GetParentPath(m_videoAsset->GetDynPath())};
 474   if (!itemDir.empty() && XFILE::CDirectory::Exists(itemDir))
 475   {
 476     CMediaSource itemSource{};
 477     itemSource.strName = g_localizeStrings.Get(36041); // * Item folder
 478     itemSource.strPath = itemDir;
 479     sources.emplace_back(itemSource);
 480   }
 481 }
 482
 483 void CGUIDialogVideoManager::RefreshSelectedVideoAsset()
 484 {
 485   if (!m_selectedVideoAsset || !m_selectedVideoAsset->HasVideoInfoTag() ||
 486       !m_videoAssetsList->Size())
 487   {
 488     m_selectedVideoAsset = std::make_shared<CFileItem>();
 489     return;
 490   }
 491
 492   const int dbId{m_selectedVideoAsset->GetVideoInfoTag()->m_iDbId};
 493   const auto it{std::find_if(m_videoAssetsList->cbegin(), m_videoAssetsList->cend(),
 494                              [dbId](const auto& entry)
 495                              { return entry->GetVideoInfoTag()->m_iDbId == dbId; })};
 496
 497   if (it == m_videoAssetsList->cend())
 498     m_selectedVideoAsset = m_videoAssetsList->Get(0);
 499 }