xbmc/addons/AddonManager.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 "AddonManager.h"
  10
  11 #include "CompileInfo.h"
  12 #include "FileItem.h"
  13 #include "FileItemList.h"
  14 #include "LangInfo.h"
  15 #include "ServiceBroker.h"
  16 #include "addons/AddonBuilder.h"
  17 #include "addons/AddonDatabase.h"
  18 #include "addons/AddonEvents.h"
  19 #include "addons/AddonInstaller.h"
  20 #include "addons/AddonRepos.h"
  21 #include "addons/AddonSystemSettings.h"
  22 #include "addons/AddonUpdateRules.h"
  23 #include "addons/IAddon.h"
  24 #include "addons/addoninfo/AddonInfo.h"
  25 #include "addons/addoninfo/AddonInfoBuilder.h"
  26 #include "addons/addoninfo/AddonType.h"
  27 #include "events/AddonManagementEvent.h"
  28 #include "events/EventLog.h"
  29 #include "events/NotificationEvent.h"
  30 #include "filesystem/Directory.h"
  31 #include "filesystem/SpecialProtocol.h"
  32 #include "utils/FileUtils.h"
  33 #include "utils/StringUtils.h"
  34 #include "utils/URIUtils.h"
  35 #include "utils/XBMCTinyXML2.h"
  36 #include "utils/XMLUtils.h"
  37 #include "utils/log.h"
  38
  39 #include <algorithm>
  40 #include <array>
  41 #include <mutex>
  42 #include <set>
  43 #include <utility>
  44
  45 using namespace XFILE;
  46
  47 namespace ADDON
  48 {
  49
  50 /**********************************************************
  51  * CAddonMgr
  52  *
  53  */
  54
  55 std::map<AddonType, IAddonMgrCallback*> CAddonMgr::m_managers;
  56
  57 static bool LoadManifest(std::set<std::string>& system, std::set<std::string>& optional)
  58 {
  59   CXBMCTinyXML doc;
  60   if (!doc.LoadFile("special://xbmc/system/addon-manifest.xml"))
  61   {
  62     CLog::Log(LOGERROR, "ADDONS: manifest missing");
  63     return false;
  64   }
  65
  66   auto root = doc.RootElement();
  67   if (!root || root->ValueStr() != "addons")
  68   {
  69     CLog::Log(LOGERROR, "ADDONS: malformed manifest");
  70     return false;
  71   }
  72
  73   auto elem = root->FirstChildElement("addon");
  74   while (elem)
  75   {
  76     if (elem->FirstChild())
  77     {
  78       if (XMLUtils::GetAttribute(elem, "optional") == "true")
  79         optional.insert(elem->FirstChild()->ValueStr());
  80       else
  81         system.insert(elem->FirstChild()->ValueStr());
  82     }
  83     elem = elem->NextSiblingElement("addon");
  84   }
  85   return true;
  86 }
  87
  88 CAddonMgr::CAddonMgr()
  89   : m_database(std::make_unique<CAddonDatabase>()),
  90     m_updateRules(std::make_unique<CAddonUpdateRules>())
  91 {
  92 }
  93
  94 CAddonMgr::~CAddonMgr()
  95 {
  96   DeInit();
  97 }
  98
  99 IAddonMgrCallback* CAddonMgr::GetCallbackForType(AddonType type)
 100 {
 101   if (m_managers.find(type) == m_managers.end())
 102     return nullptr;
 103   else
 104     return m_managers[type];
 105 }
 106
 107 bool CAddonMgr::RegisterAddonMgrCallback(AddonType type, IAddonMgrCallback* cb)
 108 {
 109   if (cb == nullptr)
 110     return false;
 111
 112   m_managers.erase(type);
 113   m_managers[type] = cb;
 114
 115   return true;
 116 }
 117
 118 void CAddonMgr::UnregisterAddonMgrCallback(AddonType type)
 119 {
 120   m_managers.erase(type);
 121 }
 122
 123 bool CAddonMgr::Init()
 124 {
 125   std::unique_lock<CCriticalSection> lock(m_critSection);
 126
 127   if (!LoadManifest(m_systemAddons, m_optionalSystemAddons))
 128   {
 129     CLog::Log(LOGERROR, "ADDONS: Failed to read manifest");
 130     return false;
 131   }
 132
 133   if (!m_database->Open())
 134     CLog::Log(LOGFATAL, "ADDONS: Failed to open database");
 135
 136   FindAddons();
 137
 138   //Ensure required add-ons are installed and enabled
 139   for (const auto& id : m_systemAddons)
 140   {
 141     AddonPtr addon;
 142     if (!GetAddon(id, addon, AddonType::UNKNOWN, OnlyEnabled::CHOICE_YES))
 143     {
 144       CLog::Log(LOGFATAL, "addon '{}' not installed or not enabled.", id);
 145       return false;
 146     }
 147   }
 148
 149   return true;
 150 }
 151
 152 void CAddonMgr::DeInit()
 153 {
 154   m_database->Close();
 155
 156   /* If temporary directory was used from add-on, delete it */
 157   if (XFILE::CDirectory::Exists(m_tempAddonBasePath))
 158     XFILE::CDirectory::RemoveRecursive(CSpecialProtocol::TranslatePath(m_tempAddonBasePath));
 159 }
 160
 161 bool CAddonMgr::HasAddons(AddonType type)
 162 {
 163   std::unique_lock<CCriticalSection> lock(m_critSection);
 164
 165   for (const auto& addonInfo : m_installedAddons)
 166   {
 167     if (addonInfo.second->HasType(type) && !IsAddonDisabled(addonInfo.second->ID()))
 168       return true;
 169   }
 170   return false;
 171 }
 172
 173 bool CAddonMgr::HasInstalledAddons(AddonType type)
 174 {
 175   std::unique_lock<CCriticalSection> lock(m_critSection);
 176
 177   for (const auto& addonInfo : m_installedAddons)
 178   {
 179     if (addonInfo.second->HasType(type))
 180       return true;
 181   }
 182   return false;
 183 }
 184
 185 void CAddonMgr::AddToUpdateableAddons(AddonPtr &pAddon)
 186 {
 187   std::unique_lock<CCriticalSection> lock(m_critSection);
 188   m_updateableAddons.push_back(pAddon);
 189 }
 190
 191 void CAddonMgr::RemoveFromUpdateableAddons(AddonPtr &pAddon)
 192 {
 193   std::unique_lock<CCriticalSection> lock(m_critSection);
 194   VECADDONS::iterator it = std::find(m_updateableAddons.begin(), m_updateableAddons.end(), pAddon);
 195
 196   if(it != m_updateableAddons.end())
 197   {
 198     m_updateableAddons.erase(it);
 199   }
 200 }
 201
 202 struct AddonIdFinder
 203 {
 204     explicit AddonIdFinder(const std::string& id)
 205       : m_id(id)
 206     {}
 207
 208     bool operator()(const AddonPtr& addon)
 209     {
 210       return m_id == addon->ID();
 211     }
 212     private:
 213     std::string m_id;
 214 };
 215
 216 bool CAddonMgr::ReloadSettings(const std::string& addonId, AddonInstanceId instanceId)
 217 {
 218   std::unique_lock<CCriticalSection> lock(m_critSection);
 219   VECADDONS::iterator it =
 220       std::find_if(m_updateableAddons.begin(), m_updateableAddons.end(), AddonIdFinder(addonId));
 221
 222   if( it != m_updateableAddons.end())
 223   {
 224     return (*it)->ReloadSettings(instanceId);
 225   }
 226   return false;
 227 }
 228
 229 std::vector<std::shared_ptr<IAddon>> CAddonMgr::GetAvailableUpdates() const
 230 {
 231   std::vector<std::shared_ptr<IAddon>> availableUpdates =
 232       GetAvailableUpdatesOrOutdatedAddons(AddonCheckType::AVAILABLE_UPDATES);
 233
 234   std::lock_guard<std::mutex> lock(m_lastAvailableUpdatesCountMutex);
 235   m_lastAvailableUpdatesCountAsString = std::to_string(availableUpdates.size());
 236
 237   return availableUpdates;
 238 }
 239
 240 const std::string& CAddonMgr::GetLastAvailableUpdatesCountAsString() const
 241 {
 242   std::lock_guard<std::mutex> lock(m_lastAvailableUpdatesCountMutex);
 243   return m_lastAvailableUpdatesCountAsString;
 244 };
 245
 246 std::vector<std::shared_ptr<IAddon>> CAddonMgr::GetOutdatedAddons() const
 247 {
 248   return GetAvailableUpdatesOrOutdatedAddons(AddonCheckType::OUTDATED_ADDONS);
 249 }
 250
 251 std::vector<std::shared_ptr<IAddon>> CAddonMgr::GetAvailableUpdatesOrOutdatedAddons(
 252     AddonCheckType addonCheckType) const
 253 {
 254   auto start = std::chrono::steady_clock::now();
 255
 256   std::vector<std::shared_ptr<IAddon>> result;
 257   std::vector<std::shared_ptr<IAddon>> installed;
 258   CAddonRepos addonRepos;
 259
 260   if (addonRepos.IsValid())
 261   {
 262     GetAddonsForUpdate(installed);
 263     addonRepos.BuildUpdateOrOutdatedList(installed, result, addonCheckType);
 264   }
 265
 266   auto end = std::chrono::steady_clock::now();
 267   auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
 268   CLog::Log(LOGDEBUG, "CAddonMgr::GetAvailableUpdatesOrOutdatedAddons took {} ms",
 269             duration.count());
 270
 271   return result;
 272 }
 273
 274 std::map<std::string, AddonWithUpdate> CAddonMgr::GetAddonsWithAvailableUpdate() const
 275 {
 276   std::unique_lock<CCriticalSection> lock(m_critSection);
 277   auto start = std::chrono::steady_clock::now();
 278
 279   std::vector<std::shared_ptr<IAddon>> installed;
 280   std::map<std::string, AddonWithUpdate> result;
 281   CAddonRepos addonRepos;
 282
 283   if (addonRepos.IsValid())
 284   {
 285     GetAddonsForUpdate(installed);
 286     addonRepos.BuildAddonsWithUpdateList(installed, result);
 287   }
 288
 289   auto end = std::chrono::steady_clock::now();
 290   auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
 291   CLog::Log(LOGDEBUG, "CAddonMgr::{} took {} ms", __func__, duration.count());
 292
 293   return result;
 294 }
 295
 296 std::vector<std::shared_ptr<IAddon>> CAddonMgr::GetCompatibleVersions(
 297     const std::string& addonId) const
 298 {
 299   std::unique_lock<CCriticalSection> lock(m_critSection);
 300   auto start = std::chrono::steady_clock::now();
 301
 302   CAddonRepos addonRepos(addonId);
 303   std::vector<std::shared_ptr<IAddon>> result;
 304
 305   if (addonRepos.IsValid())
 306     addonRepos.BuildCompatibleVersionsList(result);
 307
 308   auto end = std::chrono::steady_clock::now();
 309   auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
 310   CLog::Log(LOGDEBUG, "CAddonMgr::{} took {} ms", __func__, duration.count());
 311
 312   return result;
 313 }
 314
 315 bool CAddonMgr::HasAvailableUpdates()
 316 {
 317   return !GetAvailableUpdates().empty();
 318 }
 319
 320 std::vector<std::shared_ptr<IAddon>> CAddonMgr::GetOrphanedDependencies() const
 321 {
 322   std::vector<std::shared_ptr<IAddon>> allAddons;
 323   GetAddonsInternal(AddonType::UNKNOWN, allAddons, OnlyEnabled::CHOICE_NO,
 324                     CheckIncompatible::CHOICE_YES);
 325
 326   std::vector<std::shared_ptr<IAddon>> orphanedDependencies;
 327   for (const auto& addon : allAddons)
 328   {
 329     if (IsOrphaned(addon, allAddons))
 330     {
 331       orphanedDependencies.emplace_back(addon);
 332     }
 333   }
 334
 335   return orphanedDependencies;
 336 }
 337
 338 bool CAddonMgr::IsOrphaned(const std::shared_ptr<IAddon>& addon,
 339                            const std::vector<std::shared_ptr<IAddon>>& allAddons) const
 340 {
 341   if (CServiceBroker::GetAddonMgr().IsSystemAddon(addon->ID()) ||
 342       !CAddonType::IsDependencyType(addon->MainType()))
 343     return false;
 344
 345   auto dependsOnCapturedAddon = [&addon](const std::shared_ptr<IAddon>& _) {
 346     const auto& deps = _->GetDependencies();
 347     return std::any_of(deps.begin(), deps.end(),
 348                        [&addon](const DependencyInfo& dep) { return dep.id == addon->ID(); });
 349   };
 350
 351   return std::none_of(allAddons.begin(), allAddons.end(), dependsOnCapturedAddon);
 352 }
 353
 354 bool CAddonMgr::GetAddonsForUpdate(VECADDONS& addons) const
 355 {
 356   return GetAddonsInternal(AddonType::UNKNOWN, addons, OnlyEnabled::CHOICE_YES,
 357                            CheckIncompatible::CHOICE_YES);
 358 }
 359
 360 bool CAddonMgr::GetAddons(VECADDONS& addons) const
 361 {
 362   return GetAddonsInternal(AddonType::UNKNOWN, addons, OnlyEnabled::CHOICE_YES,
 363                            CheckIncompatible::CHOICE_NO);
 364 }
 365
 366 bool CAddonMgr::GetAddons(VECADDONS& addons, AddonType type)
 367 {
 368   return GetAddonsInternal(type, addons, OnlyEnabled::CHOICE_YES, CheckIncompatible::CHOICE_NO);
 369 }
 370
 371 bool CAddonMgr::GetInstalledAddons(VECADDONS& addons)
 372 {
 373   return GetAddonsInternal(AddonType::UNKNOWN, addons, OnlyEnabled::CHOICE_NO,
 374                            CheckIncompatible::CHOICE_NO);
 375 }
 376
 377 bool CAddonMgr::GetInstalledAddons(VECADDONS& addons, AddonType type)
 378 {
 379   return GetAddonsInternal(type, addons, OnlyEnabled::CHOICE_NO, CheckIncompatible::CHOICE_NO);
 380 }
 381
 382 bool CAddonMgr::GetDisabledAddons(VECADDONS& addons)
 383 {
 384   return CAddonMgr::GetDisabledAddons(addons, AddonType::UNKNOWN);
 385 }
 386
 387 bool CAddonMgr::GetDisabledAddons(VECADDONS& addons, AddonType type)
 388 {
 389   VECADDONS all;
 390   if (GetInstalledAddons(all, type))
 391   {
 392     std::copy_if(all.begin(), all.end(), std::back_inserter(addons),
 393         [this](const AddonPtr& addon){ return IsAddonDisabled(addon->ID()); });
 394     return true;
 395   }
 396   return false;
 397 }
 398
 399 bool CAddonMgr::GetInstallableAddons(VECADDONS& addons)
 400 {
 401   return GetInstallableAddons(addons, AddonType::UNKNOWN);
 402 }
 403
 404 bool CAddonMgr::GetInstallableAddons(VECADDONS& addons, AddonType type)
 405 {
 406   std::unique_lock<CCriticalSection> lock(m_critSection);
 407   CAddonRepos addonRepos;
 408
 409   if (!addonRepos.IsValid())
 410     return false;
 411
 412   // get all addons
 413   addonRepos.GetLatestAddonVersions(addons);
 414
 415   // go through all addons and remove all that are already installed
 416
 417   addons.erase(std::remove_if(addons.begin(), addons.end(),
 418     [this, type](const AddonPtr& addon)
 419     {
 420       bool bErase = false;
 421
 422       // check if the addon matches the provided addon type
 423       if (type != AddonType::UNKNOWN && addon->Type() != type && !addon->HasType(type))
 424         bErase = true;
 425
 426       if (!this->CanAddonBeInstalled(addon))
 427         bErase = true;
 428
 429       return bErase;
 430     }), addons.end());
 431
 432   return true;
 433 }
 434
 435 bool CAddonMgr::FindInstallableById(const std::string& addonId, AddonPtr& result)
 436 {
 437   std::unique_lock<CCriticalSection> lock(m_critSection);
 438
 439   CAddonRepos addonRepos(addonId);
 440   if (!addonRepos.IsValid())
 441     return false;
 442
 443   AddonPtr addonToUpdate;
 444
 445   // check for an update if addon is installed already
 446
 447   if (GetAddon(addonId, addonToUpdate, AddonType::UNKNOWN, OnlyEnabled::CHOICE_NO))
 448   {
 449     if (addonRepos.DoAddonUpdateCheck(addonToUpdate, result))
 450       return true;
 451   }
 452
 453   // get the latest version from all repos if the
 454   // addon is up-to-date or not installed yet
 455
 456   CLog::LogFC(
 457       LOGDEBUG, LOGADDONS,
 458       "addon {} is up-to-date or not installed. falling back to get latest version from all repos",
 459       addonId);
 460
 461   return addonRepos.GetLatestAddonVersionFromAllRepos(addonId, result);
 462 }
 463
 464 bool CAddonMgr::GetAddonsInternal(AddonType type,
 465                                   VECADDONS& addons,
 466                                   OnlyEnabled onlyEnabled,
 467                                   CheckIncompatible checkIncompatible) const
 468 {
 469   std::unique_lock<CCriticalSection> lock(m_critSection);
 470
 471   for (const auto& addonInfo : m_installedAddons)
 472   {
 473     if (type != AddonType::UNKNOWN && !addonInfo.second->HasType(type))
 474       continue;
 475
 476     if (onlyEnabled == OnlyEnabled::CHOICE_YES &&
 477         ((checkIncompatible == CheckIncompatible::CHOICE_NO &&
 478           IsAddonDisabled(addonInfo.second->ID())) ||
 479          (checkIncompatible == CheckIncompatible::CHOICE_YES &&
 480           IsAddonDisabledExcept(addonInfo.second->ID(), AddonDisabledReason::INCOMPATIBLE))))
 481       continue;
 482
 483     //FIXME: hack for skipping special dependency addons (xbmc.python etc.).
 484     //Will break if any extension point is added to them
 485     if (addonInfo.second->MainType() == AddonType::UNKNOWN)
 486       continue;
 487
 488     AddonPtr addon = CAddonBuilder::Generate(addonInfo.second, type);
 489     if (addon)
 490     {
 491       // if the addon has a running instance, grab that
 492       AddonPtr runningAddon = addon->GetRunningInstance();
 493       if (runningAddon)
 494         addon = runningAddon;
 495       addons.emplace_back(std::move(addon));
 496     }
 497   }
 498   return addons.size() > 0;
 499 }
 500
 501 bool CAddonMgr::GetIncompatibleEnabledAddonInfos(std::vector<AddonInfoPtr>& incompatible) const
 502 {
 503   return GetIncompatibleAddonInfos(incompatible, false);
 504 }
 505
 506 bool CAddonMgr::GetIncompatibleAddonInfos(std::vector<AddonInfoPtr>& incompatible,
 507                                           bool includeDisabled) const
 508 {
 509   GetAddonInfos(incompatible, true, AddonType::UNKNOWN);
 510   if (includeDisabled)
 511     GetDisabledAddonInfos(incompatible, AddonType::UNKNOWN, AddonDisabledReason::INCOMPATIBLE);
 512   incompatible.erase(std::remove_if(incompatible.begin(), incompatible.end(),
 513                                     [this](const AddonInfoPtr& a) { return IsCompatible(a); }),
 514                      incompatible.end());
 515   return !incompatible.empty();
 516 }
 517
 518 std::vector<AddonInfoPtr> CAddonMgr::MigrateAddons()
 519 {
 520   // install all addon updates
 521   std::lock_guard<std::mutex> lock(m_installAddonsMutex);
 522   CLog::Log(LOGINFO, "ADDON: waiting for add-ons to update...");
 523   VECADDONS updates;
 524   GetAddonUpdateCandidates(updates);
 525   InstallAddonUpdates(updates, true, AllowCheckForUpdates::CHOICE_NO);
 526
 527   // get addons that became incompatible and disable them
 528   std::vector<AddonInfoPtr> incompatible;
 529   GetIncompatibleAddonInfos(incompatible, true);
 530
 531   return DisableIncompatibleAddons(incompatible);
 532 }
 533
 534 std::vector<AddonInfoPtr> CAddonMgr::DisableIncompatibleAddons(
 535     const std::vector<AddonInfoPtr>& incompatible)
 536 {
 537   std::vector<AddonInfoPtr> changed;
 538   for (const auto& addon : incompatible)
 539   {
 540     CLog::Log(LOGINFO, "ADDON: {} version {} is incompatible", addon->ID(),
 541               addon->Version().asString());
 542
 543     if (!CAddonSystemSettings::GetInstance().UnsetActive(addon))
 544     {
 545       CLog::Log(LOGWARNING, "ADDON: failed to unset {}", addon->ID());
 546       continue;
 547     }
 548     if (!DisableAddon(addon->ID(), AddonDisabledReason::INCOMPATIBLE))
 549     {
 550       CLog::Log(LOGWARNING, "ADDON: failed to disable {}", addon->ID());
 551     }
 552
 553     changed.emplace_back(addon);
 554   }
 555
 556   return changed;
 557 }
 558
 559 void CAddonMgr::CheckAndInstallAddonUpdates(bool wait) const
 560 {
 561   std::lock_guard<std::mutex> lock(m_installAddonsMutex);
 562   VECADDONS updates;
 563   GetAddonUpdateCandidates(updates);
 564   InstallAddonUpdates(updates, wait, AllowCheckForUpdates::CHOICE_YES);
 565 }
 566
 567 bool CAddonMgr::GetAddonUpdateCandidates(VECADDONS& updates) const
 568 {
 569   // Get Addons in need of an update and remove all the blacklisted ones
 570   updates = GetAvailableUpdates();
 571   updates.erase(
 572       std::remove_if(updates.begin(), updates.end(),
 573                      [this](const AddonPtr& addon) { return !IsAutoUpdateable(addon->ID()); }),
 574       updates.end());
 575   return updates.empty();
 576 }
 577
 578 void CAddonMgr::SortByDependencies(VECADDONS& updates) const
 579 {
 580   std::vector<std::shared_ptr<ADDON::IAddon>> sorted;
 581   while (!updates.empty())
 582   {
 583     for (auto it = updates.begin(); it != updates.end();)
 584     {
 585       const auto& addon = *it;
 586
 587       const auto& dependencies = addon->GetDependencies();
 588       bool addToSortedList = true;
 589       // if the addon has dependencies we need to check for each dependency if it also has
 590       // an update to be installed (and in that case, if it is already in the sorted vector).
 591       // if all dependency match the said conditions, the addon doesn't depend on other addons
 592       // waiting to be updated. Hence, the addon being processed can be installed (i.e. added to
 593       // the end of the sorted vector of addon updates)
 594       for (const auto& dep : dependencies)
 595       {
 596         auto comparator = [&dep](const std::shared_ptr<ADDON::IAddon>& addon) {
 597           return addon->ID() == dep.id;
 598         };
 599
 600         if ((std::any_of(updates.begin(), updates.end(), comparator)) &&
 601             (!std::any_of(sorted.begin(), sorted.end(), comparator)))
 602         {
 603           addToSortedList = false;
 604           break;
 605         }
 606       }
 607
 608       // add to the end of sorted list of addons
 609       if (addToSortedList)
 610       {
 611         sorted.emplace_back(addon);
 612         it = updates.erase(it);
 613       }
 614       else
 615       {
 616         ++it;
 617       }
 618     }
 619   }
 620   updates = sorted;
 621 }
 622
 623 void CAddonMgr::InstallAddonUpdates(VECADDONS& updates,
 624                                     bool wait,
 625                                     AllowCheckForUpdates allowCheckForUpdates) const
 626 {
 627   // sort addons by dependencies (ensure install order) and install all
 628   SortByDependencies(updates);
 629   CAddonInstaller::GetInstance().InstallAddons(updates, wait, allowCheckForUpdates);
 630 }
 631
 632 bool CAddonMgr::GetAddon(const std::string& str,
 633                          AddonPtr& addon,
 634                          AddonType type,
 635                          OnlyEnabled onlyEnabled) const
 636 {
 637   std::unique_lock<CCriticalSection> lock(m_critSection);
 638
 639   AddonInfoPtr addonInfo = GetAddonInfo(str, type);
 640   if (addonInfo)
 641   {
 642     addon = CAddonBuilder::Generate(addonInfo, type);
 643     if (addon)
 644     {
 645       if (onlyEnabled == OnlyEnabled::CHOICE_YES && IsAddonDisabled(addonInfo->ID()))
 646         return false;
 647
 648       // if the addon has a running instance, grab that
 649       AddonPtr runningAddon = addon->GetRunningInstance();
 650       if (runningAddon)
 651         addon = runningAddon;
 652     }
 653     return nullptr != addon.get();
 654   }
 655
 656   return false;
 657 }
 658
 659 bool CAddonMgr::GetAddon(const std::string& str, AddonPtr& addon, OnlyEnabled onlyEnabled) const
 660 {
 661   return GetAddon(str, addon, AddonType::UNKNOWN, onlyEnabled);
 662 }
 663
 664 bool CAddonMgr::HasType(const std::string& id, AddonType type)
 665 {
 666   AddonPtr addon;
 667   return GetAddon(id, addon, type, OnlyEnabled::CHOICE_NO);
 668 }
 669
 670 bool CAddonMgr::FindAddon(const std::string& addonId,
 671                           const std::string& origin,
 672                           const CAddonVersion& addonVersion)
 673 {
 674   std::map<std::string, std::shared_ptr<CAddonInfo>> installedAddons;
 675
 676   FindAddons(installedAddons, "special://xbmcbin/addons");
 677   // Confirm special://xbmcbin/addons and special://xbmc/addons are not the same
 678   if (!CSpecialProtocol::ComparePath("special://xbmcbin/addons", "special://xbmc/addons"))
 679     FindAddons(installedAddons, "special://xbmc/addons");
 680   FindAddons(installedAddons, "special://home/addons");
 681
 682   const auto it = installedAddons.find(addonId);
 683   if (it == installedAddons.cend() || it->second->Version() != addonVersion)
 684     return false;
 685
 686   std::unique_lock<CCriticalSection> lock(m_critSection);
 687
 688   m_database->GetInstallData(it->second);
 689   CLog::Log(LOGINFO, "CAddonMgr::{}: {} v{} installed", __FUNCTION__, addonId,
 690             addonVersion.asString());
 691
 692   m_installedAddons[addonId] = it->second; // insert/replace entry
 693   m_database->AddInstalledAddon(it->second, origin);
 694
 695   // Reload caches
 696   std::map<std::string, AddonDisabledReason> tmpDisabled;
 697   m_database->GetDisabled(tmpDisabled);
 698   m_disabled = std::move(tmpDisabled);
 699
 700   m_updateRules->RefreshRulesMap(*m_database);
 701   return true;
 702 }
 703
 704 bool CAddonMgr::FindAddons()
 705 {
 706   ADDON_INFO_LIST installedAddons;
 707
 708   FindAddons(installedAddons, "special://xbmcbin/addons");
 709   // Confirm special://xbmcbin/addons and special://xbmc/addons are not the same
 710   if (!CSpecialProtocol::ComparePath("special://xbmcbin/addons", "special://xbmc/addons"))
 711     FindAddons(installedAddons, "special://xbmc/addons");
 712   FindAddons(installedAddons, "special://home/addons");
 713
 714   std::set<std::string> installed;
 715   for (const auto& addon : installedAddons)
 716     installed.insert(addon.second->ID());
 717
 718   std::unique_lock<CCriticalSection> lock(m_critSection);
 719
 720   // Sync with db
 721   m_database->SyncInstalled(installed, m_systemAddons, m_optionalSystemAddons);
 722   for (const auto& addon : installedAddons)
 723   {
 724     m_database->GetInstallData(addon.second);
 725     CLog::Log(LOGINFO, "CAddonMgr::{}: {} v{} installed", __FUNCTION__, addon.second->ID(),
 726               addon.second->Version().asString());
 727   }
 728
 729   m_installedAddons = std::move(installedAddons);
 730
 731   // Reload caches
 732   std::map<std::string, AddonDisabledReason> tmpDisabled;
 733   m_database->GetDisabled(tmpDisabled);
 734   m_disabled = std::move(tmpDisabled);
 735
 736   m_updateRules->RefreshRulesMap(*m_database);
 737
 738   return true;
 739 }
 740
 741 bool CAddonMgr::UnloadAddon(const std::string& addonId)
 742 {
 743   std::unique_lock<CCriticalSection> lock(m_critSection);
 744
 745   if (!IsAddonInstalled(addonId))
 746     return true;
 747
 748   AddonPtr localAddon;
 749   // can't unload an binary addon that is in use
 750   if (GetAddon(addonId, localAddon, AddonType::UNKNOWN, OnlyEnabled::CHOICE_NO) &&
 751       localAddon->IsBinary() && localAddon->IsInUse())
 752   {
 753     CLog::Log(LOGERROR, "CAddonMgr::{}: could not unload binary add-on {}, as is in use", __func__,
 754               addonId);
 755     return false;
 756   }
 757
 758   m_installedAddons.erase(addonId);
 759   CLog::Log(LOGDEBUG, "CAddonMgr::{}: {} unloaded", __func__, addonId);
 760
 761   lock.unlock();
 762   AddonEvents::Unload event(addonId);
 763   m_unloadEvents.HandleEvent(event);
 764
 765   return true;
 766 }
 767
 768 bool CAddonMgr::LoadAddon(const std::string& addonId,
 769                           const std::string& origin,
 770                           const CAddonVersion& addonVersion)
 771 {
 772   std::unique_lock<CCriticalSection> lock(m_critSection);
 773
 774   AddonPtr addon;
 775   if (GetAddon(addonId, addon, AddonType::UNKNOWN, OnlyEnabled::CHOICE_NO))
 776   {
 777     return true;
 778   }
 779
 780   if (!FindAddon(addonId, origin, addonVersion))
 781   {
 782     CLog::Log(LOGERROR, "CAddonMgr: could not reload add-on {}. FindAddon failed.", addonId);
 783     return false;
 784   }
 785
 786   if (!GetAddon(addonId, addon, AddonType::UNKNOWN, OnlyEnabled::CHOICE_NO))
 787   {
 788     CLog::Log(LOGERROR, "CAddonMgr: could not load add-on {}. No add-on with that ID is installed.",
 789               addonId);
 790     return false;
 791   }
 792
 793   lock.unlock();
 794
 795   AddonEvents::Load event(addon->ID());
 796   m_unloadEvents.HandleEvent(event);
 797
 798   if (IsAddonDisabled(addon->ID()))
 799   {
 800     EnableAddon(addon->ID());
 801     return true;
 802   }
 803
 804   m_events.Publish(AddonEvents::ReInstalled(addon->ID()));
 805   CLog::Log(LOGDEBUG, "CAddonMgr: {} successfully loaded", addon->ID());
 806   return true;
 807 }
 808
 809 void CAddonMgr::OnPostUnInstall(const std::string& id)
 810 {
 811   std::unique_lock<CCriticalSection> lock(m_critSection);
 812   m_disabled.erase(id);
 813   RemoveAllUpdateRulesFromList(id);
 814   m_events.Publish(AddonEvents::UnInstalled(id));
 815 }
 816
 817 void CAddonMgr::UpdateLastUsed(const std::string& id)
 818 {
 819   auto time = CDateTime::GetCurrentDateTime();
 820   CServiceBroker::GetJobManager()->Submit([this, id, time]() {
 821     {
 822       std::unique_lock<CCriticalSection> lock(m_critSection);
 823       m_database->SetLastUsed(id, time);
 824       auto addonInfo = GetAddonInfo(id, AddonType::UNKNOWN);
 825       if (addonInfo)
 826         addonInfo->SetLastUsed(time);
 827     }
 828     m_events.Publish(AddonEvents::MetadataChanged(id));
 829   });
 830 }
 831
 832 static void ResolveDependencies(const std::string& addonId, std::vector<std::string>& needed, std::vector<std::string>& missing)
 833 {
 834   if (std::find(needed.begin(), needed.end(), addonId) != needed.end())
 835     return;
 836
 837   AddonPtr addon;
 838   if (!CServiceBroker::GetAddonMgr().GetAddon(addonId, addon, AddonType::UNKNOWN,
 839                                               OnlyEnabled::CHOICE_NO))
 840     missing.push_back(addonId);
 841   else
 842   {
 843     needed.push_back(addonId);
 844     for (const auto& dep : addon->GetDependencies())
 845       if (!dep.optional)
 846         ResolveDependencies(dep.id, needed, missing);
 847   }
 848 }
 849
 850 bool CAddonMgr::DisableAddon(const std::string& id, AddonDisabledReason disabledReason)
 851 {
 852   std::unique_lock<CCriticalSection> lock(m_critSection);
 853   if (!CanAddonBeDisabled(id))
 854     return false;
 855   if (m_disabled.find(id) != m_disabled.end())
 856     return true; //already disabled
 857   if (!m_database->DisableAddon(id, disabledReason))
 858     return false;
 859   if (!m_disabled.emplace(id, disabledReason).second)
 860     return false;
 861
 862   //success
 863   CLog::Log(LOGDEBUG, "CAddonMgr: {} disabled", id);
 864   AddonPtr addon;
 865   if (GetAddon(id, addon, AddonType::UNKNOWN, OnlyEnabled::CHOICE_NO) && addon != nullptr)
 866   {
 867     auto eventLog = CServiceBroker::GetEventLog();
 868     if (eventLog)
 869       eventLog->Add(EventPtr(new CAddonManagementEvent(addon, 24141)));
 870   }
 871
 872   m_events.Publish(AddonEvents::Disabled(id));
 873   return true;
 874 }
 875
 876 bool CAddonMgr::UpdateDisabledReason(const std::string& id, AddonDisabledReason newDisabledReason)
 877 {
 878   std::unique_lock<CCriticalSection> lock(m_critSection);
 879   if (!IsAddonDisabled(id))
 880     return false;
 881   if (!m_database->DisableAddon(id, newDisabledReason))
 882     return false;
 883
 884   m_disabled[id] = newDisabledReason;
 885
 886   // success
 887   CLog::Log(LOGDEBUG, "CAddonMgr: DisabledReason for {} updated to {}", id,
 888             static_cast<int>(newDisabledReason));
 889   return true;
 890 }
 891
 892 bool CAddonMgr::EnableSingle(const std::string& id)
 893 {
 894   std::unique_lock<CCriticalSection> lock(m_critSection);
 895
 896   if (m_disabled.find(id) == m_disabled.end())
 897     return true; //already enabled
 898
 899   AddonPtr addon;
 900   if (!GetAddon(id, addon, AddonType::UNKNOWN, OnlyEnabled::CHOICE_NO) || addon == nullptr)
 901     return false;
 902
 903   auto eventLog = CServiceBroker::GetEventLog();
 904
 905   if (!IsCompatible(addon))
 906   {
 907     CLog::Log(LOGERROR, "Add-on '{}' is not compatible with Kodi", addon->ID());
 908     if (eventLog)
 909       eventLog->AddWithNotification(
 910           EventPtr(new CNotificationEvent(addon->Name(), 24152, EventLevel::Error)));
 911     UpdateDisabledReason(addon->ID(), AddonDisabledReason::INCOMPATIBLE);
 912     return false;
 913   }
 914
 915   if (!m_database->EnableAddon(id))
 916     return false;
 917   m_disabled.erase(id);
 918
 919   // If enabling a repo add-on without an origin, set its origin to its own id
 920   if (addon->HasType(AddonType::REPOSITORY) && addon->Origin().empty())
 921     SetAddonOrigin(id, id, false);
 922
 923   if (eventLog)
 924     eventLog->Add(EventPtr(new CAddonManagementEvent(addon, 24064)));
 925
 926   CLog::Log(LOGDEBUG, "CAddonMgr: enabled {}", addon->ID());
 927   m_events.Publish(AddonEvents::Enabled(id));
 928   return true;
 929 }
 930
 931 bool CAddonMgr::EnableAddon(const std::string& id)
 932 {
 933   if (id.empty() || !IsAddonInstalled(id))
 934     return false;
 935   std::vector<std::string> needed;
 936   std::vector<std::string> missing;
 937   ResolveDependencies(id, needed, missing);
 938   for (const auto& dep : missing)
 939     CLog::Log(LOGWARNING,
 940               "CAddonMgr: '{}' required by '{}' is missing. Add-on may not function "
 941               "correctly",
 942               dep, id);
 943   for (auto it = needed.rbegin(); it != needed.rend(); ++it)
 944     EnableSingle(*it);
 945
 946   return true;
 947 }
 948
 949 bool CAddonMgr::IsAddonDisabled(const std::string& ID) const
 950 {
 951   std::unique_lock<CCriticalSection> lock(m_critSection);
 952   return m_disabled.find(ID) != m_disabled.end();
 953 }
 954
 955 bool CAddonMgr::IsAddonDisabledExcept(const std::string& ID,
 956                                       AddonDisabledReason disabledReason) const
 957 {
 958   std::unique_lock<CCriticalSection> lock(m_critSection);
 959   const auto disabledAddon = m_disabled.find(ID);
 960   return disabledAddon != m_disabled.end() && disabledAddon->second != disabledReason;
 961 }
 962
 963 bool CAddonMgr::CanAddonBeDisabled(const std::string& ID)
 964 {
 965   if (ID.empty())
 966     return false;
 967
 968   std::unique_lock<CCriticalSection> lock(m_critSection);
 969   // Required system add-ons can not be disabled
 970   if (IsRequiredSystemAddon(ID))
 971     return false;
 972
 973   AddonPtr localAddon;
 974   // can't disable an addon that isn't installed
 975   if (!GetAddon(ID, localAddon, AddonType::UNKNOWN, OnlyEnabled::CHOICE_NO))
 976     return false;
 977
 978   // can't disable an addon that is in use
 979   if (localAddon->IsInUse())
 980     return false;
 981
 982   return true;
 983 }
 984
 985 bool CAddonMgr::CanAddonBeEnabled(const std::string& id)
 986 {
 987   return !id.empty() && IsAddonInstalled(id);
 988 }
 989
 990 bool CAddonMgr::IsAddonInstalled(const std::string& ID)
 991 {
 992   AddonPtr tmp;
 993   return GetAddon(ID, tmp, AddonType::UNKNOWN, OnlyEnabled::CHOICE_NO);
 994 }
 995
 996 bool CAddonMgr::IsAddonInstalled(const std::string& ID, const std::string& origin) const
 997 {
 998   AddonPtr tmp;
 999
1000   if (GetAddon(ID, tmp, AddonType::UNKNOWN, OnlyEnabled::CHOICE_NO) && tmp)
1001   {
1002     if (tmp->Origin() == ORIGIN_SYSTEM)
1003     {
1004       return CAddonRepos::IsOfficialRepo(origin);
1005     }
1006     else
1007     {
1008       return tmp->Origin() == origin;
1009     }
1010   }
1011   return false;
1012 }
1013
1014 bool CAddonMgr::IsAddonInstalled(const std::string& ID,
1015                                  const std::string& origin,
1016                                  const CAddonVersion& version)
1017 {
1018   AddonPtr tmp;
1019
1020   if (GetAddon(ID, tmp, AddonType::UNKNOWN, OnlyEnabled::CHOICE_NO) && tmp)
1021   {
1022     if (tmp->Origin() == ORIGIN_SYSTEM)
1023     {
1024       return CAddonRepos::IsOfficialRepo(origin) && tmp->Version() == version;
1025     }
1026     else
1027     {
1028       return tmp->Origin() == origin && tmp->Version() == version;
1029     }
1030   }
1031   return false;
1032 }
1033
1034 bool CAddonMgr::CanAddonBeInstalled(const AddonPtr& addon)
1035 {
1036   return addon != nullptr && addon->LifecycleState() != AddonLifecycleState::BROKEN &&
1037          !IsAddonInstalled(addon->ID());
1038 }
1039
1040 bool CAddonMgr::CanUninstall(const AddonPtr& addon)
1041 {
1042   return addon && CanAddonBeDisabled(addon->ID()) && !IsBundledAddon(addon->ID());
1043 }
1044
1045 bool CAddonMgr::IsBundledAddon(const std::string& id)
1046 {
1047   return XFILE::CDirectory::Exists(
1048              CSpecialProtocol::TranslatePath("special://xbmc/addons/" + id + "/")) ||
1049          XFILE::CDirectory::Exists(
1050              CSpecialProtocol::TranslatePath("special://xbmcbin/addons/" + id + "/"));
1051 }
1052
1053 bool CAddonMgr::IsSystemAddon(const std::string& id)
1054 {
1055   return IsOptionalSystemAddon(id) || IsRequiredSystemAddon(id);
1056 }
1057
1058 bool CAddonMgr::IsRequiredSystemAddon(const std::string& id)
1059 {
1060   std::unique_lock<CCriticalSection> lock(m_critSection);
1061   return std::find(m_systemAddons.begin(), m_systemAddons.end(), id) != m_systemAddons.end();
1062 }
1063
1064 bool CAddonMgr::IsOptionalSystemAddon(const std::string& id)
1065 {
1066   std::unique_lock<CCriticalSection> lock(m_critSection);
1067   return std::find(m_optionalSystemAddons.begin(), m_optionalSystemAddons.end(), id) !=
1068          m_optionalSystemAddons.end();
1069 }
1070
1071 bool CAddonMgr::LoadAddonDescription(const std::string &directory, AddonPtr &addon)
1072 {
1073   auto addonInfo = CAddonInfoBuilder::Generate(directory);
1074   if (addonInfo)
1075     addon = CAddonBuilder::Generate(addonInfo, AddonType::UNKNOWN);
1076
1077   return addon != nullptr;
1078 }
1079
1080 bool CAddonMgr::AddUpdateRuleToList(const std::string& id, AddonUpdateRule updateRule)
1081 {
1082   return m_updateRules->AddUpdateRuleToList(*m_database, id, updateRule);
1083 }
1084
1085 bool CAddonMgr::RemoveAllUpdateRulesFromList(const std::string& id)
1086 {
1087   return m_updateRules->RemoveAllUpdateRulesFromList(*m_database, id);
1088 }
1089
1090 bool CAddonMgr::RemoveUpdateRuleFromList(const std::string& id, AddonUpdateRule updateRule)
1091 {
1092   return m_updateRules->RemoveUpdateRuleFromList(*m_database, id, updateRule);
1093 }
1094
1095 bool CAddonMgr::IsAutoUpdateable(const std::string& id) const
1096 {
1097   return m_updateRules->IsAutoUpdateable(id);
1098 }
1099
1100 void CAddonMgr::PublishEventAutoUpdateStateChanged(const std::string& id)
1101 {
1102   m_events.Publish(AddonEvents::AutoUpdateStateChanged(id));
1103 }
1104
1105 void CAddonMgr::PublishInstanceAdded(const std::string& addonId, AddonInstanceId instanceId)
1106 {
1107   m_events.Publish(AddonEvents::InstanceAdded(addonId, instanceId));
1108 }
1109
1110 void CAddonMgr::PublishInstanceRemoved(const std::string& addonId, AddonInstanceId instanceId)
1111 {
1112   m_events.Publish(AddonEvents::InstanceRemoved(addonId, instanceId));
1113 }
1114
1115 bool CAddonMgr::IsCompatible(const std::shared_ptr<const IAddon>& addon) const
1116 {
1117   for (const auto& dependency : addon->GetDependencies())
1118   {
1119     if (!dependency.optional)
1120     {
1121       // Intentionally only check the xbmc.* and kodi.* magic dependencies. Everything else will
1122       // not be missing anyway, unless addon was installed in an unsupported way.
1123       if (StringUtils::StartsWith(dependency.id, "xbmc.") ||
1124           StringUtils::StartsWith(dependency.id, "kodi."))
1125       {
1126         std::shared_ptr<IAddon> dep;
1127         const bool haveDependency =
1128             GetAddon(dependency.id, dep, AddonType::UNKNOWN, OnlyEnabled::CHOICE_YES);
1129         if (!haveDependency || !dep->MeetsVersion(dependency.versionMin, dependency.version))
1130           return false;
1131       }
1132     }
1133   }
1134   return true;
1135 }
1136
1137 bool CAddonMgr::IsCompatible(const AddonInfoPtr& addonInfo) const
1138 {
1139   for (const auto& dependency : addonInfo->GetDependencies())
1140   {
1141     if (!dependency.optional)
1142     {
1143       // Intentionally only check the xbmc.* and kodi.* magic dependencies. Everything else will
1144       // not be missing anyway, unless addon was installed in an unsupported way.
1145       if (StringUtils::StartsWith(dependency.id, "xbmc.") ||
1146           StringUtils::StartsWith(dependency.id, "kodi."))
1147       {
1148         AddonInfoPtr addonInfo = GetAddonInfo(dependency.id, AddonType::UNKNOWN);
1149         if (!addonInfo || !addonInfo->MeetsVersion(dependency.versionMin, dependency.version))
1150           return false;
1151       }
1152     }
1153   }
1154   return true;
1155 }
1156
1157 std::vector<DependencyInfo> CAddonMgr::GetDepsRecursive(const std::string& id,
1158                                                         OnlyEnabledRootAddon onlyEnabledRootAddon)
1159 {
1160   std::vector<DependencyInfo> added;
1161   AddonPtr root_addon;
1162   if (!FindInstallableById(id, root_addon) &&
1163       !GetAddon(id, root_addon, AddonType::UNKNOWN, static_cast<OnlyEnabled>(onlyEnabledRootAddon)))
1164   {
1165     return added;
1166   }
1167
1168   std::vector<DependencyInfo> toProcess;
1169   for (const auto& dep : root_addon->GetDependencies())
1170     toProcess.push_back(dep);
1171
1172   while (!toProcess.empty())
1173   {
1174     auto current_dep = *toProcess.begin();
1175     toProcess.erase(toProcess.begin());
1176     if (StringUtils::StartsWith(current_dep.id, "xbmc.") ||
1177         StringUtils::StartsWith(current_dep.id, "kodi."))
1178       continue;
1179
1180     auto added_it = std::find_if(added.begin(), added.end(), [&](const DependencyInfo& d){ return d.id == current_dep.id;});
1181     if (added_it != added.end())
1182     {
1183       if (current_dep.version < added_it->version)
1184         continue;
1185
1186       bool aopt = added_it->optional;
1187       added.erase(added_it);
1188       added.push_back(current_dep);
1189       if (!current_dep.optional && aopt)
1190         continue;
1191     }
1192     else
1193       added.push_back(current_dep);
1194
1195     AddonPtr current_addon;
1196     if (FindInstallableById(current_dep.id, current_addon))
1197     {
1198       for (const auto& item : current_addon->GetDependencies())
1199         toProcess.push_back(item);
1200     }
1201   }
1202
1203   return added;
1204 }
1205
1206 bool CAddonMgr::GetAddonInfos(AddonInfos& addonInfos, bool onlyEnabled, AddonType type) const
1207 {
1208   std::unique_lock<CCriticalSection> lock(m_critSection);
1209
1210   bool forUnknown = type == AddonType::UNKNOWN;
1211   for (auto& info : m_installedAddons)
1212   {
1213     if (onlyEnabled && m_disabled.find(info.first) != m_disabled.end())
1214       continue;
1215
1216     if (info.second->MainType() != AddonType::UNKNOWN && (forUnknown || info.second->HasType(type)))
1217       addonInfos.push_back(info.second);
1218   }
1219
1220   return !addonInfos.empty();
1221 }
1222
1223 std::vector<AddonInfoPtr> CAddonMgr::GetAddonInfos(bool onlyEnabled,
1224                                                    const std::vector<AddonType>& types) const
1225 {
1226   std::vector<AddonInfoPtr> infos;
1227   if (types.empty())
1228     return infos;
1229
1230   std::unique_lock<CCriticalSection> lock(m_critSection);
1231
1232   for (auto& info : m_installedAddons)
1233   {
1234     if (onlyEnabled && m_disabled.find(info.first) != m_disabled.end())
1235       continue;
1236
1237     if (info.second->MainType() == AddonType::UNKNOWN)
1238       continue;
1239
1240     const auto it = std::find_if(types.begin(), types.end(),
1241                                  [info](AddonType t) { return info.second->HasType(t); });
1242     if (it != types.end())
1243       infos.emplace_back(info.second);
1244   }
1245
1246   return infos;
1247 }
1248
1249 bool CAddonMgr::GetDisabledAddonInfos(std::vector<AddonInfoPtr>& addonInfos, AddonType type) const
1250 {
1251   return GetDisabledAddonInfos(addonInfos, type, AddonDisabledReason::NONE);
1252 }
1253
1254 bool CAddonMgr::GetDisabledAddonInfos(std::vector<AddonInfoPtr>& addonInfos,
1255                                       AddonType type,
1256                                       AddonDisabledReason disabledReason) const
1257 {
1258   std::unique_lock<CCriticalSection> lock(m_critSection);
1259
1260   bool forUnknown = type == AddonType::UNKNOWN;
1261   for (const auto& info : m_installedAddons)
1262   {
1263     const auto disabledAddon = m_disabled.find(info.first);
1264     if (disabledAddon == m_disabled.end())
1265       continue;
1266
1267     if (info.second->MainType() != AddonType::UNKNOWN &&
1268         (forUnknown || info.second->HasType(type)) &&
1269         (disabledReason == AddonDisabledReason::NONE || disabledReason == disabledAddon->second))
1270       addonInfos.emplace_back(info.second);
1271   }
1272
1273   return !addonInfos.empty();
1274 }
1275
1276 const AddonInfoPtr CAddonMgr::GetAddonInfo(const std::string& id, AddonType type) const
1277 {
1278   std::unique_lock<CCriticalSection> lock(m_critSection);
1279
1280   auto addon = m_installedAddons.find(id);
1281   if (addon != m_installedAddons.end())
1282     if ((type == AddonType::UNKNOWN || addon->second->HasType(type)))
1283       return addon->second;
1284
1285   return nullptr;
1286 }
1287
1288 void CAddonMgr::FindAddons(ADDON_INFO_LIST& addonmap, const std::string& path)
1289 {
1290   CFileItemList items;
1291   if (XFILE::CDirectory::GetDirectory(path, items, "", XFILE::DIR_FLAG_NO_FILE_DIRS))
1292   {
1293     for (int i = 0; i < items.Size(); ++i)
1294     {
1295       std::string path = items[i]->GetPath();
1296       if (CFileUtils::Exists(path + "addon.xml"))
1297       {
1298         AddonInfoPtr addonInfo = CAddonInfoBuilder::Generate(path);
1299         if (addonInfo)
1300         {
1301           const auto& it = addonmap.find(addonInfo->ID());
1302           if (it != addonmap.end())
1303           {
1304             if (it->second->Version() > addonInfo->Version())
1305             {
1306               CLog::Log(LOGWARNING, "CAddonMgr::{}: Addon '{}' already present with higher version {} at '{}' - other version {} at '{}' will be ignored",
1307                            __FUNCTION__, addonInfo->ID(), it->second->Version().asString(), it->second->Path(), addonInfo->Version().asString(), addonInfo->Path());
1308               continue;
1309             }
1310             CLog::Log(LOGDEBUG, "CAddonMgr::{}: Addon '{}' already present with version {} at '{}' replaced with version {} at '{}'",
1311                          __FUNCTION__, addonInfo->ID(), it->second->Version().asString(), it->second->Path(), addonInfo->Version().asString(), addonInfo->Path());
1312           }
1313
1314           addonmap[addonInfo->ID()] = addonInfo;
1315         }
1316       }
1317     }
1318   }
1319 }
1320
1321 AddonOriginType CAddonMgr::GetAddonOriginType(const AddonPtr& addon) const
1322 {
1323   if (addon->Origin() == ORIGIN_SYSTEM)
1324     return AddonOriginType::SYSTEM;
1325   else if (!addon->Origin().empty())
1326     return AddonOriginType::REPOSITORY;
1327   else
1328     return AddonOriginType::MANUAL;
1329 }
1330
1331 bool CAddonMgr::IsAddonDisabledWithReason(const std::string& ID,
1332                                           AddonDisabledReason disabledReason) const
1333 {
1334   std::unique_lock<CCriticalSection> lock(m_critSection);
1335   const auto& disabledAddon = m_disabled.find(ID);
1336   return disabledAddon != m_disabled.end() && disabledAddon->second == disabledReason;
1337 }
1338
1339 /*!
1340  * @brief Addon update and install management.
1341  */
1342 /*@{{{*/
1343
1344 bool CAddonMgr::SetAddonOrigin(const std::string& addonId, const std::string& repoAddonId, bool isUpdate)
1345 {
1346   std::unique_lock<CCriticalSection> lock(m_critSection);
1347
1348   m_database->SetOrigin(addonId, repoAddonId);
1349   if (isUpdate)
1350     m_database->SetLastUpdated(addonId, CDateTime::GetCurrentDateTime());
1351
1352   // If available in manager update
1353   const AddonInfoPtr info = GetAddonInfo(addonId, AddonType::UNKNOWN);
1354   if (info)
1355     m_database->GetInstallData(info);
1356   return true;
1357 }
1358
1359 bool CAddonMgr::AddonsFromRepoXML(const RepositoryDirInfo& repo,
1360                                   const std::string& xml,
1361                                   std::vector<AddonInfoPtr>& addons)
1362 {
1363   CXBMCTinyXML2 doc;
1364   if (!doc.Parse(xml))
1365   {
1366     CLog::Log(LOGERROR, "CAddonMgr::{}: Failed to parse addons.xml", __func__);
1367     return false;
1368   }
1369
1370   if (doc.RootElement() == nullptr ||
1371       !StringUtils::EqualsNoCase(doc.RootElement()->Value(), "addons"))
1372   {
1373     CLog::Log(LOGERROR, "CAddonMgr::{}: Failed to parse addons.xml. Malformed", __func__);
1374     return false;
1375   }
1376
1377   // each addon XML should have a UTF-8 declaration
1378   auto element = doc.RootElement()->FirstChildElement("addon");
1379   while (element)
1380   {
1381     auto addonInfo = CAddonInfoBuilder::Generate(element, repo);
1382     if (addonInfo)
1383       addons.emplace_back(addonInfo);
1384
1385     element = element->NextSiblingElement("addon");
1386   }
1387
1388   return true;
1389 }
1390
1391 /*@}}}*/
1392
1393 } /* namespace ADDON */