xbmc/favourites/FavouritesService.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 "FavouritesService.h"
  10
  11 #include "FileItem.h"
  12 #include "GUIPassword.h"
  13 #include "ServiceBroker.h"
  14 #include "Util.h"
  15 #include "favourites/FavouritesURL.h"
  16 #include "input/WindowTranslator.h"
  17 #include "music/MusicFileItemClassify.h"
  18 #include "profiles/ProfileManager.h"
  19 #include "settings/SettingsComponent.h"
  20 #include "utils/ContentUtils.h"
  21 #include "utils/FileUtils.h"
  22 #include "utils/URIUtils.h"
  23 #include "utils/XBMCTinyXML2.h"
  24 #include "utils/log.h"
  25 #include "video/VideoFileItemClassify.h"
  26
  27 #include <mutex>
  28
  29 using namespace KODI;
  30
  31 namespace
  32 {
  33 bool IsMediasourceOfFavItemUnlocked(const std::shared_ptr<CFileItem>& item)
  34 {
  35   if (!item)
  36   {
  37     CLog::Log(LOGERROR, "{}: No item passed (nullptr).", __func__);
  38     return true;
  39   }
  40
  41   if (!item->IsFavourite())
  42   {
  43     CLog::Log(LOGERROR, "{}: Wrong item passed (not a favourite).", __func__);
  44     return true;
  45   }
  46
  47   const auto settingsComponent = CServiceBroker::GetSettingsComponent();
  48   if (!settingsComponent)
  49   {
  50     CLog::Log(LOGERROR, "{}: returned nullptr.", __func__);
  51     return true;
  52   }
  53
  54   const auto profileManager = settingsComponent->GetProfileManager();
  55   if (!profileManager)
  56   {
  57     CLog::Log(LOGERROR, "{}: returned nullptr.", __func__);
  58     return true;
  59   }
  60
  61   const CFavouritesURL url(item->GetPath());
  62   if (!url.IsValid())
  63   {
  64     CLog::Log(LOGERROR, "{}: Invalid exec string (syntax error).", __func__);
  65     return true;
  66   }
  67
  68   const CFavouritesURL::Action action = url.GetAction();
  69
  70   if (action != CFavouritesURL::Action::PLAY_MEDIA &&
  71       action != CFavouritesURL::Action::SHOW_PICTURE)
  72     return true;
  73
  74   const CFileItem itemToCheck(url.GetTarget(), url.IsDir());
  75
  76   if (action == CFavouritesURL::Action::PLAY_MEDIA)
  77   {
  78     if (VIDEO::IsVideo(itemToCheck))
  79     {
  80       if (!profileManager->GetCurrentProfile().videoLocked())
  81         return g_passwordManager.IsMediaFileUnlocked("video", itemToCheck.GetPath());
  82
  83       return false;
  84     }
  85     else if (MUSIC::IsAudio(itemToCheck))
  86     {
  87       if (!profileManager->GetCurrentProfile().musicLocked())
  88         return g_passwordManager.IsMediaFileUnlocked("music", itemToCheck.GetPath());
  89
  90       return false;
  91     }
  92   }
  93   else if (action == CFavouritesURL::Action::SHOW_PICTURE && itemToCheck.IsPicture())
  94   {
  95     if (!profileManager->GetCurrentProfile().picturesLocked())
  96       return g_passwordManager.IsMediaFileUnlocked("pictures", itemToCheck.GetPath());
  97
  98     return false;
  99   }
 100
 101   return true;
 102 }
 103
 104 bool LoadFromFile(const std::string& strPath, CFileItemList& items)
 105 {
 106   CXBMCTinyXML2 doc;
 107   if (!doc.LoadFile(strPath))
 108   {
 109     CLog::Log(LOGERROR, "Unable to load {} (line {})", strPath, doc.ErrorLineNum());
 110     return false;
 111   }
 112   auto* root = doc.RootElement();
 113   if (!root || strcmp(root->Value(), "favourites"))
 114   {
 115     CLog::Log(LOGERROR, "Favourites.xml doesn't contain the <favourites> root element");
 116     return false;
 117   }
 118
 119   auto* favourite = root->FirstChildElement("favourite");
 120   while (favourite)
 121   {
 122     // format:
 123     // <favourite name="Cool Video" thumb="foo.jpg">PlayMedia(c:\videos\cool_video.avi)</favourite>
 124     // <favourite name="My Album" thumb="bar.tbn">ActivateWindow(MyMusic,c:\music\my album)</favourite>
 125     // <favourite name="Apple Movie Trailers" thumb="path_to_thumb.png">RunScript(special://xbmc/scripts/apple movie trailers/default.py)</favourite>
 126     const char *name = favourite->Attribute("name");
 127     const char *thumb = favourite->Attribute("thumb");
 128     if (name && favourite->FirstChild())
 129     {
 130       const std::string favURL(
 131           CFavouritesURL(CExecString(favourite->FirstChild()->Value())).GetURL());
 132       if (!items.Contains(favURL))
 133       {
 134         const CFileItemPtr item(std::make_shared<CFileItem>(name));
 135         item->SetPath(favURL);
 136         if (thumb)
 137           item->SetArt("thumb", thumb);
 138         items.Add(item);
 139       }
 140     }
 141     favourite = favourite->NextSiblingElement("favourite");
 142   }
 143   return true;
 144 }
 145 } // unnamed namespace
 146
 147 CFavouritesService::CFavouritesService(std::string userDataFolder) : m_favourites("favourites://")
 148 {
 149   ReInit(std::move(userDataFolder));
 150 }
 151
 152 void CFavouritesService::ReInit(std::string userDataFolder)
 153 {
 154   std::unique_lock<CCriticalSection> lock(m_criticalSection);
 155
 156   m_userDataFolder = std::move(userDataFolder);
 157   m_favourites.Clear();
 158   m_targets.clear();
 159   m_favourites.SetContent("favourites");
 160
 161   std::string favourites = "special://xbmc/system/favourites.xml";
 162   if (CFileUtils::Exists(favourites))
 163     LoadFromFile(favourites, m_favourites);
 164   else
 165     CLog::Log(LOGDEBUG, "CFavourites::Load - no system favourites found, skipping");
 166
 167   favourites = URIUtils::AddFileToFolder(m_userDataFolder, "favourites.xml");
 168   if (CFileUtils::Exists(favourites))
 169     LoadFromFile(favourites, m_favourites);
 170   else
 171     CLog::Log(LOGDEBUG, "CFavourites::Load - no userdata favourites found, skipping");
 172 }
 173
 174 void CFavouritesService::CleanupTargetsCache(const CFileItem& item)
 175 {
 176   // Cleanup cache. Resume info etc. of cached target items might need refresh.
 177   std::unique_lock<CCriticalSection> lock(m_criticalSection);
 178
 179   const std::string dynPath{item.GetDynPath()};
 180   std::erase_if(m_targets,
 181                 [&dynPath](const auto& entry)
 182                 {
 183                   auto const& [key, value] = entry;
 184                   return (value->GetDynPath() == dynPath);
 185                 });
 186 }
 187
 188 void CFavouritesService::OnPlaybackStopped(const CFileItem& item)
 189 {
 190   CleanupTargetsCache(item);
 191 }
 192
 193 void CFavouritesService::OnPlaybackEnded(const CFileItem& item)
 194 {
 195   CleanupTargetsCache(item);
 196 }
 197
 198 bool CFavouritesService::Persist()
 199 {
 200   CXBMCTinyXML2 doc;
 201   auto* element = doc.NewElement("favourites");
 202   auto* rootNode = doc.InsertEndChild(element);
 203   if (!rootNode)
 204     return false;
 205
 206   for (const auto& item : m_favourites)
 207   {
 208     auto* favNode = doc.NewElement("favourite");
 209     favNode->SetAttribute("name", item->GetLabel().c_str());
 210     if (item->HasArt("thumb"))
 211       favNode->SetAttribute("thumb", item->GetArt("thumb").c_str());
 212
 213     auto* execute = doc.NewText(CFavouritesURL(item->GetPath()).GetExecString().c_str());
 214     favNode->InsertEndChild(execute);
 215     rootNode->InsertEndChild(favNode);
 216   }
 217
 218   auto path = URIUtils::AddFileToFolder(m_userDataFolder, "favourites.xml");
 219   return doc.SaveFile(path);
 220 }
 221
 222 bool CFavouritesService::Save(const CFileItemList& items)
 223 {
 224   {
 225     std::unique_lock<CCriticalSection> lock(m_criticalSection);
 226     m_favourites.Clear();
 227     m_targets.clear();
 228     m_favourites.Copy(items);
 229     Persist();
 230   }
 231   OnUpdated();
 232   return true;
 233 }
 234
 235 void CFavouritesService::OnUpdated()
 236 {
 237   m_events.Publish(FavouritesUpdated{});
 238 }
 239
 240 bool CFavouritesService::AddOrRemove(const CFileItem& item, int contextWindow)
 241 {
 242   {
 243     std::unique_lock<CCriticalSection> lock(m_criticalSection);
 244
 245     const std::shared_ptr<CFileItem> match{GetFavourite(item, contextWindow)};
 246     if (match)
 247     {
 248       // remove the item
 249       const auto it = m_targets.find(match->GetPath());
 250       if (it != m_targets.end())
 251         m_targets.erase(it);
 252
 253       m_favourites.Remove(match.get());
 254     }
 255     else
 256     {
 257       // create our new favourite item
 258       const auto favourite{std::make_shared<CFileItem>(item.GetLabel())};
 259       if (item.GetLabel().empty())
 260         favourite->SetLabel(CUtil::GetTitleFromPath(item.GetPath(), item.m_bIsFolder));
 261       favourite->SetArt("thumb", ContentUtils::GetPreferredArtImage(item));
 262       const std::string favUrl{CFavouritesURL(item, contextWindow).GetURL()};
 263       favourite->SetPath(favUrl);
 264       m_favourites.Add(favourite);
 265     }
 266     Persist();
 267   }
 268   OnUpdated();
 269   return true;
 270 }
 271
 272 std::shared_ptr<CFileItem> CFavouritesService::GetFavourite(const CFileItem& item,
 273                                                             int contextWindow) const
 274 {
 275   std::unique_lock<CCriticalSection> lock(m_criticalSection);
 276
 277   const CFavouritesURL favURL{item, contextWindow};
 278   const bool isVideoDb{URIUtils::IsVideoDb(favURL.GetTarget())};
 279   const bool isMusicDb{URIUtils::IsMusicDb(favURL.GetTarget())};
 280
 281   for (const auto& favItem : m_favourites)
 282   {
 283     const CFavouritesURL favItemURL{*favItem, contextWindow};
 284
 285     // Compare the whole target URLs
 286     if (favItemURL.GetTarget() == item.GetPath())
 287       return favItem;
 288
 289     // Compare the target URLs ignoring optional parameters
 290     if (favItemURL.GetAction() == favURL.GetAction() &&
 291         (favItemURL.GetAction() != CFavouritesURL::Action::ACTIVATE_WINDOW ||
 292          favItemURL.GetWindowID() == favURL.GetWindowID()))
 293     {
 294       if (favItemURL.GetTarget() == favURL.GetTarget())
 295         return favItem;
 296
 297       // Check videodb and musicdb paths. Might be different strings pointing to same resource!
 298       // Example: "musicdb://recentlyaddedalbums/4711/" and "musicdb://recentlyplayedalbums/4711/",
 299       // both pointing to same album with db id 4711.
 300       if ((isVideoDb && URIUtils::IsVideoDb(favItemURL.GetTarget())) ||
 301           (isMusicDb && URIUtils::IsMusicDb(favItemURL.GetTarget())))
 302       {
 303         const std::shared_ptr<CFileItem> targetItem{ResolveFavourite(*favItem)};
 304         if (targetItem && targetItem->IsSamePath(&item))
 305           return favItem;
 306       }
 307     }
 308   }
 309   return {};
 310 }
 311
 312 bool CFavouritesService::IsFavourited(const CFileItem& item, int contextWindow) const
 313 {
 314   return (GetFavourite(item, contextWindow) != nullptr);
 315 }
 316
 317 std::shared_ptr<CFileItem> CFavouritesService::ResolveFavourite(const CFileItem& item) const
 318 {
 319   if (item.IsFavourite())
 320   {
 321     std::unique_lock<CCriticalSection> lock(m_criticalSection);
 322
 323     const auto it = m_targets.find(item.GetPath());
 324     if (it != m_targets.end())
 325       return (*it).second;
 326
 327     const CFavouritesURL favURL{item.GetPath()};
 328     if (favURL.IsValid())
 329     {
 330       auto targetItem{std::make_shared<CFileItem>(favURL.GetTarget(), favURL.IsDir())};
 331       targetItem->LoadDetails();
 332       if (favURL.GetWindowID() != -1)
 333       {
 334         const std::string window{CWindowTranslator::TranslateWindow(favURL.GetWindowID())};
 335         targetItem->SetProperty("targetwindow", CVariant{window});
 336       }
 337       m_targets.insert({item.GetPath(), targetItem});
 338       return targetItem;
 339     }
 340   }
 341   return {};
 342 }
 343
 344 int CFavouritesService::Size() const
 345 {
 346   std::unique_lock<CCriticalSection> lock(m_criticalSection);
 347   return m_favourites.Size();
 348 }
 349
 350 void CFavouritesService::GetAll(CFileItemList& items) const
 351 {
 352   std::unique_lock<CCriticalSection> lock(m_criticalSection);
 353   items.Clear();
 354   if (g_passwordManager.IsMasterLockUnlocked(false)) // don't prompt
 355   {
 356     items.Copy(m_favourites, true); // copy items
 357   }
 358   else
 359   {
 360     for (const auto& fav : m_favourites)
 361     {
 362       if (IsMediasourceOfFavItemUnlocked(fav))
 363         items.Add(fav);
 364     }
 365   }
 366
 367   int index = 0;
 368   for (const auto& item : items)
 369   {
 370     const CFavouritesURL favURL(item->GetPath());
 371     item->SetProperty("favourite.action", favURL.GetActionLabel());
 372     item->SetProperty("favourite.provider", favURL.GetProviderLabel());
 373     item->SetProperty("favourite.index", index++);
 374   }
 375 }
 376
 377 void CFavouritesService::RefreshFavourites()
 378 {
 379   m_events.Publish(FavouritesUpdated{});
 380 }