xbmc/video/dialogs/GUIDialogSubtitles.cpp

   1 /*
   2  *  Copyright (C) 2005-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 "GUIDialogSubtitles.h"
  10
  11 #include "FileItem.h"
  12 #include "FileItemList.h"
  13 #include "LangInfo.h"
  14 #include "ServiceBroker.h"
  15 #include "URL.h"
  16 #include "Util.h"
  17 #include "addons/AddonManager.h"
  18 #include "addons/addoninfo/AddonInfo.h"
  19 #include "addons/addoninfo/AddonType.h"
  20 #include "addons/gui/GUIDialogAddonSettings.h"
  21 #include "application/Application.h"
  22 #include "application/ApplicationComponents.h"
  23 #include "application/ApplicationPlayer.h"
  24 #include "cores/IPlayer.h"
  25 #include "dialogs/GUIDialogContextMenu.h"
  26 #include "dialogs/GUIDialogKaiToast.h"
  27 #include "filesystem/AddonsDirectory.h"
  28 #include "filesystem/Directory.h"
  29 #include "filesystem/File.h"
  30 #include "filesystem/SpecialProtocol.h"
  31 #include "filesystem/StackDirectory.h"
  32 #include "guilib/GUIComponent.h"
  33 #include "guilib/GUIKeyboardFactory.h"
  34 #include "guilib/GUIWindowManager.h"
  35 #include "guilib/LocalizeStrings.h"
  36 #include "input/actions/ActionIDs.h"
  37 #include "settings/Settings.h"
  38 #include "settings/SettingsComponent.h"
  39 #include "settings/lib/Setting.h"
  40 #include "utils/JobManager.h"
  41 #include "utils/LangCodeExpander.h"
  42 #include "utils/StringUtils.h"
  43 #include "utils/URIUtils.h"
  44 #include "utils/Variant.h"
  45 #include "utils/log.h"
  46 #include "video/VideoDatabase.h"
  47
  48 #include <mutex>
  49
  50 using namespace ADDON;
  51 using namespace XFILE;
  52
  53 namespace
  54 {
  55 constexpr int CONTROL_NAMELABEL = 100;
  56 constexpr int CONTROL_NAMELOGO = 110;
  57 constexpr int CONTROL_SUBLIST = 120;
  58 constexpr int CONTROL_SUBSEXIST = 130;
  59 constexpr int CONTROL_SUBSTATUS = 140;
  60 constexpr int CONTROL_SERVICELIST = 150;
  61 constexpr int CONTROL_MANUALSEARCH = 160;
  62
  63 enum class SUBTITLE_SERVICE_CONTEXT_BUTTONS
  64 {
  65   ADDON_SETTINGS,
  66   ADDON_DISABLE
  67 };
  68 } // namespace
  69
  70 /*! \brief simple job to retrieve a directory and store a string (language)
  71  */
  72 class CSubtitlesJob: public CJob
  73 {
  74 public:
  75   CSubtitlesJob(const CURL &url, const std::string &language) : m_url(url), m_language(language)
  76   {
  77     m_items = new CFileItemList;
  78   }
  79   ~CSubtitlesJob() override
  80   {
  81     delete m_items;
  82   }
  83   bool DoWork() override
  84   {
  85     CDirectory::GetDirectory(m_url.Get(), *m_items, "", DIR_FLAG_DEFAULTS);
  86     return true;
  87   }
  88   bool operator==(const CJob *job) const override
  89   {
  90     if (strcmp(job->GetType(),GetType()) == 0)
  91     {
  92       const CSubtitlesJob* rjob = dynamic_cast<const CSubtitlesJob*>(job);
  93       if (rjob)
  94       {
  95         return m_url.Get() == rjob->m_url.Get() &&
  96                m_language == rjob->m_language;
  97       }
  98     }
  99     return false;
 100   }
 101   const CFileItemList *GetItems() const { return m_items; }
 102   const CURL &GetURL() const { return m_url; }
 103   const std::string &GetLanguage() const { return m_language; }
 104 private:
 105   CURL           m_url;
 106   CFileItemList *m_items;
 107   std::string    m_language;
 108 };
 109
 110 CGUIDialogSubtitles::CGUIDialogSubtitles(void)
 111     : CGUIDialog(WINDOW_DIALOG_SUBTITLES, "DialogSubtitles.xml")
 112     , m_subtitles(new CFileItemList)
 113     , m_serviceItems(new CFileItemList)
 114 {
 115   m_loadType = KEEP_IN_MEMORY;
 116 }
 117
 118 CGUIDialogSubtitles::~CGUIDialogSubtitles(void)
 119 {
 120   CancelJobs();
 121   delete m_subtitles;
 122   delete m_serviceItems;
 123 }
 124
 125 bool CGUIDialogSubtitles::OnMessage(CGUIMessage& message)
 126 {
 127   if (message.GetMessage() == GUI_MSG_CLICKED)
 128   {
 129     int iControl = message.GetSenderId();
 130     bool selectAction = (message.GetParam1() == ACTION_SELECT_ITEM ||
 131                          message.GetParam1() == ACTION_MOUSE_LEFT_CLICK);
 132
 133     bool contextMenuAction = (message.GetParam1() == ACTION_CONTEXT_MENU ||
 134                               message.GetParam1() == ACTION_MOUSE_RIGHT_CLICK);
 135
 136     if (selectAction && iControl == CONTROL_SUBLIST)
 137     {
 138       CGUIMessage msg(GUI_MSG_ITEM_SELECTED, GetID(), CONTROL_SUBLIST);
 139       OnMessage(msg);
 140
 141       int item = msg.GetParam1();
 142       if (item >= 0 && item < m_subtitles->Size())
 143         Download(*m_subtitles->Get(item));
 144       return true;
 145     }
 146     else if (selectAction && iControl == CONTROL_SERVICELIST)
 147     {
 148       CGUIMessage msg(GUI_MSG_ITEM_SELECTED, GetID(), CONTROL_SERVICELIST);
 149       OnMessage(msg);
 150
 151       int item = msg.GetParam1();
 152       if (item >= 0 && item < m_serviceItems->Size())
 153       {
 154         SetService(m_serviceItems->Get(item)->GetProperty("Addon.ID").asString());
 155         Search();
 156       }
 157       return true;
 158     }
 159     else if (contextMenuAction && iControl == CONTROL_SERVICELIST)
 160     {
 161       CGUIMessage msg(GUI_MSG_ITEM_SELECTED, GetID(), CONTROL_SERVICELIST);
 162       OnMessage(msg);
 163
 164       const int itemIdx = msg.GetParam1();
 165       if (itemIdx >= 0 && itemIdx < m_serviceItems->Size())
 166       {
 167         OnSubtitleServiceContextMenu(itemIdx);
 168       }
 169     }
 170     else if (iControl == CONTROL_MANUALSEARCH)
 171     {
 172       //manual search
 173       if (CGUIKeyboardFactory::ShowAndGetInput(m_strManualSearch, CVariant{g_localizeStrings.Get(24121)}, true))
 174       {
 175         Search(m_strManualSearch);
 176         return true;
 177       }
 178     }
 179   }
 180   else if (message.GetMessage() == GUI_MSG_WINDOW_DEINIT)
 181   {
 182     auto& components = CServiceBroker::GetAppComponents();
 183     const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 184     // Resume the video if the user has requested it
 185     if (appPlayer->IsPaused() && m_pausedOnRun)
 186       appPlayer->Pause();
 187
 188     CGUIDialog::OnMessage(message);
 189
 190     ClearSubtitles();
 191     ClearServices();
 192     return true;
 193   }
 194   return CGUIDialog::OnMessage(message);
 195 }
 196
 197 void CGUIDialogSubtitles::OnInitWindow()
 198 {
 199   // Pause the video if the user has requested it
 200   m_pausedOnRun = false;
 201   auto& components = CServiceBroker::GetAppComponents();
 202   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 203   if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(
 204           CSettings::SETTING_SUBTITLES_PAUSEONSEARCH) &&
 205       !appPlayer->IsPaused())
 206   {
 207     appPlayer->Pause();
 208     m_pausedOnRun = true;
 209   }
 210
 211   FillServices();
 212   CGUIWindow::OnInitWindow();
 213   Search();
 214 }
 215
 216 void CGUIDialogSubtitles::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
 217 {
 218   if (m_bInvalidated)
 219   {
 220     // take copies of our variables to ensure we don't hold the lock for long.
 221     std::string status;
 222     CFileItemList subs;
 223     {
 224       std::unique_lock<CCriticalSection> lock(m_critsection);
 225       status = m_status;
 226       subs.Assign(*m_subtitles);
 227     }
 228     SET_CONTROL_LABEL(CONTROL_SUBSTATUS, status);
 229
 230     if (m_updateSubsList)
 231     {
 232       CGUIMessage message(GUI_MSG_LABEL_BIND, GetID(), CONTROL_SUBLIST, 0, 0, &subs);
 233       OnMessage(message);
 234       if (!subs.IsEmpty())
 235       {
 236         // focus subtitles list
 237         CGUIMessage msg(GUI_MSG_SETFOCUS, GetID(), CONTROL_SUBLIST);
 238         OnMessage(msg);
 239       }
 240       m_updateSubsList = false;
 241     }
 242
 243     int control = GetFocusedControlID();
 244     // nothing has focus
 245     if (!control)
 246     {
 247       CGUIMessage msg(GUI_MSG_SETFOCUS, GetID(), m_subtitles->IsEmpty() ?
 248                       CONTROL_SERVICELIST : CONTROL_SUBLIST);
 249       OnMessage(msg);
 250     }
 251     // subs list is focused but we have no subs
 252     else if (control == CONTROL_SUBLIST && m_subtitles->IsEmpty())
 253     {
 254       CGUIMessage msg(GUI_MSG_SETFOCUS, GetID(), CONTROL_SERVICELIST);
 255       OnMessage(msg);
 256     }
 257   }
 258   CGUIDialog::Process(currentTime, dirtyregions);
 259 }
 260
 261 void CGUIDialogSubtitles::FillServices()
 262 {
 263   ClearServices();
 264
 265   VECADDONS addons;
 266   CServiceBroker::GetAddonMgr().GetAddons(addons, AddonType::SUBTITLE_MODULE);
 267
 268   if (addons.empty())
 269   {
 270     UpdateStatus(NO_SERVICES);
 271     return;
 272   }
 273
 274   std::string defaultService;
 275   const CFileItem &item = g_application.CurrentUnstackedItem();
 276   if (item.GetVideoContentType() == VideoDbContentType::TVSHOWS ||
 277       item.GetVideoContentType() == VideoDbContentType::EPISODES)
 278     // Set default service for tv shows
 279     defaultService = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_SUBTITLES_TV);
 280   else
 281     // Set default service for filemode and movies
 282     defaultService = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_SUBTITLES_MOVIE);
 283
 284   std::string service = addons.front()->ID();
 285   for (VECADDONS::const_iterator addonIt = addons.begin(); addonIt != addons.end(); ++addonIt)
 286   {
 287     CFileItemPtr item(CAddonsDirectory::FileItemFromAddon(*addonIt, "plugin://" + (*addonIt)->ID(), false));
 288     m_serviceItems->Add(item);
 289     if ((*addonIt)->ID() == defaultService)
 290       service = (*addonIt)->ID();
 291   }
 292
 293   // Bind our services to the UI
 294   CGUIMessage msg(GUI_MSG_LABEL_BIND, GetID(), CONTROL_SERVICELIST, 0, 0, m_serviceItems);
 295   OnMessage(msg);
 296
 297   SetService(service);
 298 }
 299
 300 bool CGUIDialogSubtitles::SetService(const std::string &service)
 301 {
 302   if (service != m_currentService)
 303   {
 304     m_currentService = service;
 305     CLog::Log(LOGDEBUG, "New Service [{}] ", m_currentService);
 306
 307     CFileItemPtr currentService = GetService();
 308     // highlight this item in the skin
 309     for (int i = 0; i < m_serviceItems->Size(); i++)
 310     {
 311       CFileItemPtr pItem = m_serviceItems->Get(i);
 312       pItem->Select(pItem == currentService);
 313     }
 314
 315     SET_CONTROL_LABEL(CONTROL_NAMELABEL, currentService->GetLabel());
 316
 317     if (currentService->HasAddonInfo())
 318     {
 319       std::string icon = URIUtils::AddFileToFolder(currentService->GetAddonInfo()->Path(), "logo.png");
 320       SET_CONTROL_FILENAME(CONTROL_NAMELOGO, icon);
 321     }
 322
 323     const auto& components = CServiceBroker::GetAppComponents();
 324     const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 325     if (appPlayer->GetSubtitleCount() == 0)
 326       SET_CONTROL_HIDDEN(CONTROL_SUBSEXIST);
 327     else
 328       SET_CONTROL_VISIBLE(CONTROL_SUBSEXIST);
 329
 330     return true;
 331   }
 332   return false;
 333 }
 334
 335 const CFileItemPtr CGUIDialogSubtitles::GetService() const
 336 {
 337   for (int i = 0; i < m_serviceItems->Size(); i++)
 338   {
 339     if (m_serviceItems->Get(i)->GetProperty("Addon.ID") == m_currentService)
 340       return m_serviceItems->Get(i);
 341   }
 342   return CFileItemPtr();
 343 }
 344
 345 void CGUIDialogSubtitles::Search(const std::string &search/*=""*/)
 346 {
 347   if (m_currentService.empty())
 348     return; // no services available
 349
 350   UpdateStatus(SEARCHING);
 351   ClearSubtitles();
 352
 353   CURL url("plugin://" + m_currentService + "/");
 354   if (!search.empty())
 355   {
 356     url.SetOption("action", "manualsearch");
 357     url.SetOption("searchstring", search);
 358   }
 359   else
 360     url.SetOption("action", "search");
 361
 362   const std::shared_ptr<CSettings> settings = CServiceBroker::GetSettingsComponent()->GetSettings();
 363   SettingConstPtr setting = settings->GetSetting(CSettings::SETTING_SUBTITLES_LANGUAGES);
 364   if (setting)
 365     url.SetOption("languages", setting->ToString());
 366
 367   // Check for stacking
 368   if (g_application.CurrentFileItem().IsStack())
 369     url.SetOption("stack", "1");
 370
 371   std::string preferredLanguage = settings->GetString(CSettings::SETTING_LOCALE_SUBTITLELANGUAGE);
 372
 373   if (StringUtils::EqualsNoCase(preferredLanguage, "original"))
 374   {
 375     AudioStreamInfo info;
 376     std::string strLanguage;
 377
 378     const auto& components = CServiceBroker::GetAppComponents();
 379     const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 380     appPlayer->GetAudioStreamInfo(CURRENT_STREAM, info);
 381
 382     if (!g_LangCodeExpander.Lookup(info.language, strLanguage))
 383       strLanguage = "Unknown";
 384
 385     preferredLanguage = strLanguage;
 386   }
 387   else if (StringUtils::EqualsNoCase(preferredLanguage, "default"))
 388     preferredLanguage = g_langInfo.GetEnglishLanguageName();
 389
 390   url.SetOption("preferredlanguage", preferredLanguage);
 391
 392   AddJob(new CSubtitlesJob(url, ""));
 393 }
 394
 395 void CGUIDialogSubtitles::OnJobComplete(unsigned int jobID, bool success, CJob *job)
 396 {
 397   const CURL &url             = static_cast<CSubtitlesJob*>(job)->GetURL();
 398   const CFileItemList *items  = static_cast<CSubtitlesJob*>(job)->GetItems();
 399   const std::string &language = static_cast<CSubtitlesJob*>(job)->GetLanguage();
 400   if (url.GetOption("action") == "search" || url.GetOption("action") == "manualsearch")
 401     OnSearchComplete(items);
 402   else
 403     OnDownloadComplete(items, language);
 404   CJobQueue::OnJobComplete(jobID, success, job);
 405 }
 406
 407 void CGUIDialogSubtitles::OnSearchComplete(const CFileItemList *items)
 408 {
 409   std::unique_lock<CCriticalSection> lock(m_critsection);
 410   m_subtitles->Assign(*items);
 411   UpdateStatus(SEARCH_COMPLETE);
 412   m_updateSubsList = true;
 413   MarkDirtyRegion();
 414
 415   const auto& components = CServiceBroker::GetAppComponents();
 416   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 417   if (!items->IsEmpty() && appPlayer->GetSubtitleCount() == 0 &&
 418       m_LastAutoDownloaded != g_application.CurrentFile() &&
 419       CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(
 420           CSettings::SETTING_SUBTITLES_DOWNLOADFIRST))
 421   {
 422     CFileItemPtr item = items->Get(0);
 423     CLog::Log(LOGDEBUG, "{} - Automatically download first subtitle: {}", __FUNCTION__,
 424               item->GetLabel2());
 425     m_LastAutoDownloaded = g_application.CurrentFile();
 426     Download(*item);
 427   }
 428
 429   SetInvalid();
 430 }
 431
 432 void CGUIDialogSubtitles::OnSubtitleServiceContextMenu(int itemIdx)
 433 {
 434   const auto service = m_serviceItems->Get(itemIdx);
 435
 436   CContextButtons buttons;
 437   // Subtitle addon settings
 438   buttons.Add(static_cast<int>(SUBTITLE_SERVICE_CONTEXT_BUTTONS::ADDON_SETTINGS),
 439               g_localizeStrings.Get(21417));
 440   // Disable addon
 441   buttons.Add(static_cast<int>(SUBTITLE_SERVICE_CONTEXT_BUTTONS::ADDON_DISABLE),
 442               g_localizeStrings.Get(24021));
 443
 444   auto idx = static_cast<SUBTITLE_SERVICE_CONTEXT_BUTTONS>(CGUIDialogContextMenu::Show(buttons));
 445   switch (idx)
 446   {
 447     case SUBTITLE_SERVICE_CONTEXT_BUTTONS::ADDON_SETTINGS:
 448     {
 449       AddonPtr addon;
 450       if (CServiceBroker::GetAddonMgr().GetAddon(service->GetProperty("Addon.ID").asString(), addon,
 451                                                  AddonType::SUBTITLE_MODULE,
 452                                                  OnlyEnabled::CHOICE_YES))
 453       {
 454         CGUIDialogAddonSettings::ShowForAddon(addon);
 455       }
 456       else
 457       {
 458         CLog::Log(LOGERROR, "{} - Could not open settings for addon: {}", __FUNCTION__,
 459                   service->GetProperty("Addon.ID").asString());
 460       }
 461       break;
 462     }
 463     case SUBTITLE_SERVICE_CONTEXT_BUTTONS::ADDON_DISABLE:
 464     {
 465       CServiceBroker::GetAddonMgr().DisableAddon(service->GetProperty("Addon.ID").asString(),
 466                                                  AddonDisabledReason::USER);
 467       const bool currentActiveServiceWasDisabled =
 468           m_currentService == service->GetProperty("Addon.ID").asString();
 469       FillServices();
 470       // restart search if the current active service was disabled
 471       if (currentActiveServiceWasDisabled && !m_serviceItems->IsEmpty())
 472       {
 473         Search();
 474       }
 475       // if no more services are available make sure the subtitle list is cleaned up
 476       else if (m_serviceItems->IsEmpty())
 477       {
 478         ClearSubtitles();
 479       }
 480       break;
 481     }
 482     default:
 483       break;
 484   }
 485 }
 486
 487 void CGUIDialogSubtitles::UpdateStatus(STATUS status)
 488 {
 489   std::unique_lock<CCriticalSection> lock(m_critsection);
 490   std::string label;
 491   switch (status)
 492   {
 493     case NO_SERVICES:
 494       label = g_localizeStrings.Get(24114);
 495       break;
 496     case SEARCHING:
 497       label = g_localizeStrings.Get(24107);
 498       break;
 499     case SEARCH_COMPLETE:
 500       if (!m_subtitles->IsEmpty())
 501         label = StringUtils::Format(g_localizeStrings.Get(24108), m_subtitles->Size());
 502       else
 503         label = g_localizeStrings.Get(24109);
 504       break;
 505     case DOWNLOADING:
 506       label = g_localizeStrings.Get(24110);
 507       break;
 508     default:
 509       break;
 510   }
 511   if (label != m_status)
 512   {
 513     m_status = label;
 514     SetInvalid();
 515   }
 516 }
 517
 518 void CGUIDialogSubtitles::Download(const CFileItem &subtitle)
 519 {
 520   UpdateStatus(DOWNLOADING);
 521
 522   // subtitle URL should be of the form plugin://<addonid>/?param=foo&param=bar
 523   // we just append (if not already present) the action=download parameter.
 524   CURL url(subtitle.GetURL());
 525   if (url.GetOption("action").empty())
 526     url.SetOption("action", "download");
 527
 528   AddJob(new CSubtitlesJob(url, subtitle.GetLabel()));
 529 }
 530
 531 void CGUIDialogSubtitles::OnDownloadComplete(const CFileItemList *items, const std::string &language)
 532 {
 533   if (items->IsEmpty())
 534   {
 535     CFileItemPtr service = GetService();
 536     if (service)
 537       CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error, service->GetLabel(), g_localizeStrings.Get(24113));
 538     UpdateStatus(SEARCH_COMPLETE);
 539     return;
 540   }
 541
 542   SUBTITLE_STORAGEMODE storageMode = (SUBTITLE_STORAGEMODE) CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_SUBTITLES_STORAGEMODE);
 543
 544   // Get (unstacked) path
 545   std::string strCurrentFile = g_application.CurrentUnstackedItem().GetDynPath();
 546
 547   std::string strDownloadPath = "special://temp";
 548   std::string strDestPath;
 549   std::vector<std::string> vecFiles;
 550
 551   std::string strCurrentFilePath;
 552   const std::string subPath = CSpecialProtocol::TranslatePath("special://subtitles");
 553
 554   if (subPath.empty() && URIUtils::IsHTTP(strCurrentFile))
 555   {
 556     strCurrentFile = "TempSubtitle";
 557     vecFiles.push_back(strCurrentFile);
 558   }
 559   else
 560   {
 561     if (!subPath.empty())
 562       strDownloadPath = subPath;
 563
 564     /** Get item's folder for sub storage, special case for RAR/ZIP items
 565      * @todo We need some way to avoid special casing this all over the place
 566      * for rar/zip (perhaps modify GetDirectory?)
 567      */
 568     if (URIUtils::IsInRAR(strCurrentFile) || URIUtils::IsInZIP(strCurrentFile))
 569       strCurrentFilePath = URIUtils::GetDirectory(CURL(strCurrentFile).GetHostName());
 570     else
 571       strCurrentFilePath = URIUtils::GetDirectory(strCurrentFile);
 572
 573     // Handle stacks
 574     if (g_application.CurrentFileItem().IsStack() && items->Size() > 1)
 575     {
 576       CStackDirectory::GetPaths(g_application.CurrentFileItem().GetPath(), vecFiles);
 577       // Make sure (stack) size is the same as the size of the items handed to us, else fallback to single item
 578       if (items->Size() != (int) vecFiles.size())
 579       {
 580         vecFiles.clear();
 581         vecFiles.push_back(strCurrentFile);
 582       }
 583     }
 584     else
 585     {
 586       vecFiles.push_back(strCurrentFile);
 587     }
 588
 589     if (storageMode == SUBTITLE_STORAGEMODE_MOVIEPATH &&
 590         CUtil::SupportsWriteFileOperations(strCurrentFilePath))
 591     {
 592       strDestPath = strCurrentFilePath;
 593     }
 594   }
 595
 596   // Use fallback?
 597   if (strDestPath.empty())
 598     strDestPath = strDownloadPath;
 599
 600   // Extract the language and appropriate extension
 601   std::string strSubLang;
 602   g_LangCodeExpander.ConvertToISO6391(language, strSubLang);
 603
 604   // Iterate over all items to transfer
 605   for (unsigned int i = 0; i < vecFiles.size() && i < (unsigned int) items->Size(); i++)
 606   {
 607     std::string strUrl = items->Get(i)->GetPath();
 608     std::string strFileName = URIUtils::GetFileName(vecFiles[i]);
 609     URIUtils::RemoveExtension(strFileName);
 610
 611     // construct subtitle path
 612     std::string strSubExt = URIUtils::GetExtension(strUrl);
 613     std::string strSubName = StringUtils::Format("{}.{}{}", strFileName, strSubLang, strSubExt);
 614
 615     // Handle URL encoding:
 616     std::string strDownloadFile = URIUtils::ChangeBasePath(strCurrentFilePath, strSubName, strDownloadPath);
 617     std::string strDestFile = strDownloadFile;
 618
 619     if (!CFile::Copy(strUrl, strDownloadFile))
 620     {
 621       CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error, strSubName, g_localizeStrings.Get(24113));
 622       CLog::Log(LOGERROR, "{} - Saving of subtitle {} to {} failed", __FUNCTION__, strUrl,
 623                 strDownloadFile);
 624     }
 625     else
 626     {
 627       if (strDestPath != strDownloadPath)
 628       {
 629         // Handle URL encoding:
 630         std::string strTryDestFile = URIUtils::ChangeBasePath(strCurrentFilePath, strSubName, strDestPath);
 631
 632         /* Copy the file from temp to our final destination, if that fails fallback to download path
 633          * (ie. special://subtitles or use special://temp). Note that after the first item strDownloadPath equals strDestpath
 634          * so that all remaining items (including the .idx below) are copied directly to their final destination and thus all
 635          * items end up in the same folder
 636          */
 637         CLog::Log(LOGDEBUG, "{} - Saving subtitle {} to {}", __FUNCTION__, strDownloadFile,
 638                   strTryDestFile);
 639         if (CFile::Copy(strDownloadFile, strTryDestFile))
 640         {
 641           CFile::Delete(strDownloadFile);
 642           strDestFile = strTryDestFile;
 643           strDownloadPath = strDestPath; // Update download path so all the other items get directly downloaded to our final destination
 644         }
 645         else
 646         {
 647           CLog::Log(LOGWARNING, "{} - Saving of subtitle {} to {} failed. Falling back to {}",
 648                     __FUNCTION__, strDownloadFile, strTryDestFile, strDownloadPath);
 649           strDestPath = strDownloadPath; // Copy failed, use fallback for the rest of the items
 650         }
 651       }
 652       else
 653       {
 654         CLog::Log(LOGDEBUG, "{} - Saved subtitle {} to {}", __FUNCTION__, strUrl, strDownloadFile);
 655       }
 656
 657       // for ".sub" subtitles we check if ".idx" counterpart exists and copy that as well
 658       if (StringUtils::EqualsNoCase(strSubExt, ".sub"))
 659       {
 660         strUrl = URIUtils::ReplaceExtension(strUrl, ".idx");
 661         if(CFile::Exists(strUrl))
 662         {
 663           std::string strSubNameIdx = StringUtils::Format("{}.{}.idx", strFileName, strSubLang);
 664           // Handle URL encoding:
 665           strDestFile = URIUtils::ChangeBasePath(strCurrentFilePath, strSubNameIdx, strDestPath);
 666           CFile::Copy(strUrl, strDestFile);
 667         }
 668       }
 669
 670       // Set sub for currently playing (stack) item
 671       if (vecFiles[i] == strCurrentFile)
 672         SetSubtitles(strDestFile);
 673     }
 674   }
 675
 676   // Notify window manager that a subtitle was downloaded
 677   CGUIMessage msg(GUI_MSG_SUBTITLE_DOWNLOADED, 0, 0);
 678   CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg);
 679
 680   // Close the window
 681   Close();
 682 }
 683
 684 void CGUIDialogSubtitles::ClearSubtitles()
 685 {
 686   CGUIMessage msg(GUI_MSG_LABEL_RESET, GetID(), CONTROL_SUBLIST);
 687   OnMessage(msg);
 688   std::unique_lock<CCriticalSection> lock(m_critsection);
 689   m_subtitles->Clear();
 690 }
 691
 692 void CGUIDialogSubtitles::ClearServices()
 693 {
 694   CGUIMessage msg(GUI_MSG_LABEL_RESET, GetID(), CONTROL_SERVICELIST);
 695   OnMessage(msg);
 696   m_serviceItems->Clear();
 697   m_currentService.clear();
 698 }
 699
 700 void CGUIDialogSubtitles::SetSubtitles(const std::string &subtitle)
 701 {
 702   auto& components = CServiceBroker::GetAppComponents();
 703   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 704   appPlayer->AddSubtitle(subtitle);
 705 }