xbmc/addons/AddonRepos.cpp

   1 /*
   2  *  Copyright (C) 2005-2020 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 "AddonRepos.h"
  10
  11 #include "CompileInfo.h"
  12 #include "ServiceBroker.h"
  13 #include "addons/Addon.h"
  14 #include "addons/AddonManager.h"
  15 #include "addons/AddonRepoInfo.h"
  16 #include "addons/AddonSystemSettings.h"
  17 #include "addons/Repository.h"
  18 #include "addons/RepositoryUpdater.h"
  19 #include "addons/addoninfo/AddonInfo.h"
  20 #include "addons/addoninfo/AddonType.h"
  21 #include "messaging/helpers/DialogOKHelper.h"
  22 #include "utils/StringUtils.h"
  23 #include "utils/log.h"
  24
  25 #include <algorithm>
  26 #include <vector>
  27
  28 namespace
  29 {
  30 constexpr auto ALL_ADDON_IDS = "";
  31 constexpr auto ALL_REPOSITORIES = nullptr;
  32 } // anonymous namespace
  33
  34 using namespace ADDON;
  35
  36 static std::vector<RepoInfo> officialRepoInfos = CCompileInfo::LoadOfficialRepoInfos();
  37
  38 /**********************************************************
  39  * CAddonRepos
  40  *
  41  */
  42
  43 CAddonRepos::CAddonRepos() : m_addonMgr(CServiceBroker::GetAddonMgr())
  44 {
  45   m_valid = m_addonDb.Open() && LoadAddonsFromDatabase(ALL_ADDON_IDS, ALL_REPOSITORIES);
  46 }
  47
  48 CAddonRepos::CAddonRepos(const std::string& addonId) : m_addonMgr(CServiceBroker::GetAddonMgr())
  49 {
  50   m_valid = m_addonDb.Open() && LoadAddonsFromDatabase(addonId, ALL_REPOSITORIES);
  51 }
  52
  53 CAddonRepos::CAddonRepos(const std::shared_ptr<IAddon>& repoAddon)
  54   : m_addonMgr(CServiceBroker::GetAddonMgr())
  55 {
  56   m_valid = m_addonDb.Open() && LoadAddonsFromDatabase(ALL_ADDON_IDS, repoAddon);
  57 }
  58
  59 bool CAddonRepos::IsFromOfficialRepo(const std::shared_ptr<IAddon>& addon,
  60                                      CheckAddonPath checkAddonPath)
  61 {
  62   auto comparator = [&](const RepoInfo& officialRepo) {
  63     if (checkAddonPath == CheckAddonPath::CHOICE_YES)
  64     {
  65       return (addon->Origin() == officialRepo.m_repoId &&
  66               StringUtils::StartsWithNoCase(addon->Path(), officialRepo.m_origin));
  67     }
  68
  69     return addon->Origin() == officialRepo.m_repoId;
  70   };
  71
  72   return addon->Origin() == ORIGIN_SYSTEM ||
  73          std::any_of(officialRepoInfos.begin(), officialRepoInfos.end(), comparator);
  74 }
  75
  76 bool CAddonRepos::IsOfficialRepo(const std::string& repoId)
  77 {
  78   return repoId == ORIGIN_SYSTEM || std::any_of(officialRepoInfos.begin(), officialRepoInfos.end(),
  79                                                 [&repoId](const RepoInfo& officialRepo) {
  80                                                   return repoId == officialRepo.m_repoId;
  81                                                 });
  82 }
  83
  84 bool CAddonRepos::LoadAddonsFromDatabase(const std::string& addonId,
  85                                          const std::shared_ptr<IAddon>& repoAddon)
  86 {
  87   if (repoAddon != ALL_REPOSITORIES)
  88   {
  89     if (!m_addonDb.GetRepositoryContent(repoAddon->ID(), m_allAddons))
  90     {
  91       // Repo content is invalid. Ask for update and wait.
  92       CServiceBroker::GetRepositoryUpdater().CheckForUpdates(
  93           std::static_pointer_cast<CRepository>(repoAddon));
  94       CServiceBroker::GetRepositoryUpdater().Await();
  95
  96       if (!m_addonDb.GetRepositoryContent(repoAddon->ID(), m_allAddons))
  97       {
  98
  99         // could not connect to repository
 100         KODI::MESSAGING::HELPERS::ShowOKDialogText(CVariant{repoAddon->Name()}, CVariant{24991});
 101         return false;
 102       }
 103     }
 104   }
 105   else if (addonId == ALL_ADDON_IDS)
 106   {
 107     // load full repository content
 108     m_addonDb.GetRepositoryContent(m_allAddons);
 109     if (m_allAddons.empty())
 110       return true;
 111   }
 112   else
 113   {
 114     // load specific addonId only
 115     m_addonDb.FindByAddonId(addonId, m_allAddons);
 116   }
 117
 118   if (m_allAddons.empty())
 119     return false;
 120
 121   for (const auto& addon : m_allAddons)
 122   {
 123     if (m_addonMgr.IsCompatible(addon))
 124     {
 125       m_addonsByRepoMap[addon->Origin()].emplace(addon->ID(), addon);
 126     }
 127   }
 128
 129   for (const auto& [repoId, addonsPerRepo] : m_addonsByRepoMap)
 130   {
 131     CLog::LogFC(LOGDEBUG, LOGADDONS, "{} - {} addon(s) loaded", repoId, addonsPerRepo.size());
 132
 133     for (const auto& [addonId, addonToAdd] : addonsPerRepo)
 134     {
 135       if (IsFromOfficialRepo(addonToAdd, CheckAddonPath::CHOICE_YES))
 136       {
 137         AddAddonIfLatest(addonToAdd, m_latestOfficialVersions);
 138       }
 139       else
 140       {
 141         AddAddonIfLatest(addonToAdd, m_latestPrivateVersions);
 142       }
 143
 144       // add to latestVersionsByRepo
 145       AddAddonIfLatest(repoId, addonToAdd, m_latestVersionsByRepo);
 146     }
 147   }
 148
 149   return true;
 150 }
 151
 152 void CAddonRepos::AddAddonIfLatest(const std::shared_ptr<IAddon>& addonToAdd,
 153                                    std::map<std::string, std::shared_ptr<IAddon>>& map) const
 154 {
 155   const auto latestKnownIt = map.find(addonToAdd->ID());
 156   if (latestKnownIt == map.end() || addonToAdd->Version() > latestKnownIt->second->Version())
 157     map[addonToAdd->ID()] = addonToAdd;
 158 }
 159
 160 void CAddonRepos::AddAddonIfLatest(
 161     const std::string& repoId,
 162     const std::shared_ptr<IAddon>& addonToAdd,
 163     std::map<std::string, std::map<std::string, std::shared_ptr<IAddon>>>& map) const
 164 {
 165   bool doInsert{true};
 166
 167   const auto latestVersionByRepoIt = map.find(repoId);
 168   if (latestVersionByRepoIt != map.end()) // we already have this repository in the outer map
 169   {
 170     const auto& latestVersionEntryByRepo = latestVersionByRepoIt->second;
 171     const auto latestKnownIt = latestVersionEntryByRepo.find(addonToAdd->ID());
 172
 173     if (latestKnownIt != latestVersionEntryByRepo.end() &&
 174         addonToAdd->Version() <= latestKnownIt->second->Version())
 175     {
 176       doInsert = false;
 177     }
 178   }
 179
 180   if (doInsert)
 181     map[repoId][addonToAdd->ID()] = addonToAdd;
 182 }
 183
 184 void CAddonRepos::BuildUpdateOrOutdatedList(const std::vector<std::shared_ptr<IAddon>>& installed,
 185                                             std::vector<std::shared_ptr<IAddon>>& result,
 186                                             AddonCheckType addonCheckType) const
 187 {
 188   std::shared_ptr<IAddon> update;
 189
 190   CLog::LogFC(LOGDEBUG, LOGADDONS, "Building {} list from installed add-ons",
 191               addonCheckType == AddonCheckType::OUTDATED_ADDONS ? "outdated" : "update");
 192   for (const auto& addon : installed)
 193   {
 194     if (DoAddonUpdateCheck(addon, update))
 195     {
 196       result.emplace_back(addonCheckType == AddonCheckType::OUTDATED_ADDONS ? addon : update);
 197     }
 198   }
 199 }
 200
 201 void CAddonRepos::BuildAddonsWithUpdateList(
 202     const std::vector<std::shared_ptr<IAddon>>& installed,
 203     std::map<std::string, AddonWithUpdate>& addonsWithUpdate) const
 204 {
 205   std::shared_ptr<IAddon> update;
 206
 207   CLog::LogFC(LOGDEBUG, LOGADDONS,
 208               "Building combined addons-with-update map from installed add-ons");
 209   for (const auto& addon : installed)
 210   {
 211     if (DoAddonUpdateCheck(addon, update))
 212     {
 213       addonsWithUpdate.try_emplace(addon->ID(), addon, update);
 214     }
 215   }
 216 }
 217
 218 bool CAddonRepos::DoAddonUpdateCheck(const std::shared_ptr<IAddon>& addon,
 219                                      std::shared_ptr<IAddon>& update) const
 220 {
 221   CLog::LogFC(LOGDEBUG, LOGADDONS, "update check: addonID = {} / Origin = {} / Version = {}",
 222               addon->ID(), addon->Origin(), addon->Version().asString());
 223
 224   update.reset();
 225
 226   const AddonRepoUpdateMode updateMode =
 227       CAddonSystemSettings::GetInstance().GetAddonRepoUpdateMode();
 228
 229   bool hasOfficialUpdate = FindAddonAndCheckForUpdate(addon, m_latestOfficialVersions, update);
 230
 231   // addons with an empty origin have at least been checked against official repositories
 232   if (!addon->Origin().empty())
 233   {
 234     if (ORIGIN_SYSTEM != addon->Origin() && !hasOfficialUpdate) // not a system addon
 235     {
 236
 237       // we didn't find an official update.
 238       // either version is current or that add-on isn't contained in official repos
 239       if (IsFromOfficialRepo(addon, CheckAddonPath::CHOICE_NO))
 240       {
 241
 242         // check further if it IS contained in official repos
 243         if (updateMode == AddonRepoUpdateMode::ANY_REPOSITORY)
 244         {
 245           if (!FindAddonAndCheckForUpdate(addon, m_latestPrivateVersions, update))
 246           {
 247             return false;
 248           }
 249         }
 250       }
 251       else
 252       {
 253         // ...we check for updates in the origin repo only
 254         const auto repoEntryIt = m_latestVersionsByRepo.find(addon->Origin());
 255         if (repoEntryIt != m_latestVersionsByRepo.end())
 256         {
 257           if (!FindAddonAndCheckForUpdate(addon, repoEntryIt->second, update))
 258           {
 259             return false;
 260           }
 261         }
 262       }
 263     }
 264   }
 265
 266   if (update != nullptr)
 267   {
 268     CLog::LogFC(LOGDEBUG, LOGADDONS, "-- found -->: addonID = {} / Origin = {} / Version = {}",
 269                 update->ID(), update->Origin(), update->Version().asString());
 270     return true;
 271   }
 272
 273   return false;
 274 }
 275
 276 bool CAddonRepos::FindAddonAndCheckForUpdate(
 277     const std::shared_ptr<IAddon>& addonToCheck,
 278     const std::map<std::string, std::shared_ptr<IAddon>>& map,
 279     std::shared_ptr<IAddon>& update) const
 280 {
 281   const auto remoteIt = map.find(addonToCheck->ID());
 282   if (remoteIt != map.end()) // is addon in the desired map?
 283   {
 284     if ((remoteIt->second->Version() > addonToCheck->Version()) ||
 285         m_addonMgr.IsAddonDisabledWithReason(addonToCheck->ID(), AddonDisabledReason::INCOMPATIBLE))
 286     {
 287       // return addon update
 288       update = remoteIt->second;
 289       return true; // update found
 290     }
 291   }
 292
 293   // either addon wasn't found or it's up to date
 294   return false;
 295 }
 296
 297 bool CAddonRepos::GetLatestVersionByMap(const std::string& addonId,
 298                                         const std::map<std::string, std::shared_ptr<IAddon>>& map,
 299                                         std::shared_ptr<IAddon>& addon) const
 300 {
 301   const auto remoteIt = map.find(addonId);
 302   if (remoteIt != map.end()) // is addon in the desired map?
 303   {
 304     addon = remoteIt->second;
 305     return true;
 306   }
 307
 308   return false;
 309 }
 310
 311 bool CAddonRepos::GetLatestAddonVersionFromAllRepos(const std::string& addonId,
 312                                                     std::shared_ptr<IAddon>& addon) const
 313 {
 314   const AddonRepoUpdateMode updateMode =
 315       CAddonSystemSettings::GetInstance().GetAddonRepoUpdateMode();
 316
 317   bool hasOfficialVersion = GetLatestVersionByMap(addonId, m_latestOfficialVersions, addon);
 318
 319   if (hasOfficialVersion)
 320   {
 321     if (updateMode == AddonRepoUpdateMode::ANY_REPOSITORY)
 322     {
 323       std::shared_ptr<IAddon> thirdPartyAddon;
 324
 325       // only use this version if it's higher than the official one
 326       if (GetLatestVersionByMap(addonId, m_latestPrivateVersions, thirdPartyAddon))
 327       {
 328         if (thirdPartyAddon->Version() > addon->Version())
 329           addon = thirdPartyAddon;
 330       }
 331     }
 332   }
 333   else
 334   {
 335     if (!GetLatestVersionByMap(addonId, m_latestPrivateVersions, addon))
 336       return false;
 337   }
 338
 339   return true;
 340 }
 341
 342 void CAddonRepos::GetLatestAddonVersions(std::vector<std::shared_ptr<IAddon>>& addonList) const
 343 {
 344   const AddonRepoUpdateMode updateMode =
 345       CAddonSystemSettings::GetInstance().GetAddonRepoUpdateMode();
 346
 347   addonList.clear();
 348
 349   // first we insert all official addon versions into the resulting vector
 350
 351   for (const auto& officialVersion : m_latestOfficialVersions)
 352     addonList.emplace_back(officialVersion.second);
 353
 354   // then we insert private addon versions if they don't exist in the official map
 355   // or installation from ANY_REPOSITORY is allowed and the private version is higher
 356
 357   for (const auto& [privateVersionId, privateVersion] : m_latestPrivateVersions)
 358   {
 359     const auto officialVersionIt = m_latestOfficialVersions.find(privateVersionId);
 360
 361     if (officialVersionIt == m_latestOfficialVersions.end() ||
 362         (updateMode == AddonRepoUpdateMode::ANY_REPOSITORY &&
 363          privateVersion->Version() > officialVersionIt->second->Version()))
 364     {
 365       addonList.emplace_back(privateVersion);
 366     }
 367   }
 368 }
 369
 370 void CAddonRepos::GetLatestAddonVersionsFromAllRepos(
 371     std::vector<std::shared_ptr<IAddon>>& addonList) const
 372 {
 373   const AddonRepoUpdateMode updateMode =
 374       CAddonSystemSettings::GetInstance().GetAddonRepoUpdateMode();
 375
 376   addonList.clear();
 377
 378   // first we insert all official addon versions into the resulting vector
 379
 380   for (const auto& officialVersion : m_latestOfficialVersions)
 381     addonList.emplace_back(officialVersion.second);
 382
 383   // then we insert latest version per addon and repository if they don't exist in the official map
 384   // or installation from ANY_REPOSITORY is allowed and the private version is higher
 385
 386   for (const auto& repo : m_latestVersionsByRepo)
 387   {
 388     // content of official repos is stored in m_latestVersionsByRepo too
 389     // so we need to filter them out
 390
 391     if (std::none_of(officialRepoInfos.begin(), officialRepoInfos.end(),
 392                      [&repo](const ADDON::RepoInfo& officialRepo)
 393                      { return repo.first == officialRepo.m_repoId; }))
 394     {
 395       for (const auto& [latestAddonId, latestAddon] : repo.second)
 396       {
 397         const auto officialVersionIt = m_latestOfficialVersions.find(latestAddonId);
 398
 399         if (officialVersionIt == m_latestOfficialVersions.end() ||
 400             (updateMode == AddonRepoUpdateMode::ANY_REPOSITORY &&
 401              latestAddon->Version() > officialVersionIt->second->Version()))
 402         {
 403           addonList.emplace_back(latestAddon);
 404         }
 405       }
 406     }
 407   }
 408 }
 409
 410 bool CAddonRepos::FindDependency(const std::string& dependsId,
 411                                  const std::string& parentRepoId,
 412                                  std::shared_ptr<IAddon>& dependencyToInstall,
 413                                  std::shared_ptr<CRepository>& repoForDep) const
 414 {
 415   const AddonRepoUpdateMode updateMode =
 416       CAddonSystemSettings::GetInstance().GetAddonRepoUpdateMode();
 417
 418   bool dependencyHasOfficialVersion =
 419       GetLatestVersionByMap(dependsId, m_latestOfficialVersions, dependencyToInstall);
 420
 421   if (dependencyHasOfficialVersion)
 422   {
 423     if (updateMode == AddonRepoUpdateMode::ANY_REPOSITORY)
 424     {
 425       std::shared_ptr<IAddon> thirdPartyDependency;
 426
 427       // only use this version if it's higher than the official one
 428       if (GetLatestVersionByMap(dependsId, m_latestPrivateVersions, thirdPartyDependency))
 429       {
 430         if (thirdPartyDependency->Version() > dependencyToInstall->Version())
 431           dependencyToInstall = thirdPartyDependency;
 432       }
 433     }
 434   }
 435   else
 436   {
 437     // If we didn't find an official version of this dependency
 438     // ...we check in the origin repo of the parent
 439     if (!FindDependencyByParentRepo(dependsId, parentRepoId, dependencyToInstall))
 440       return false;
 441   }
 442
 443   // we got the dependency, so now get a repository-pointer to return
 444
 445   std::shared_ptr<IAddon> tmp;
 446   if (!m_addonMgr.GetAddon(dependencyToInstall->Origin(), tmp, AddonType::REPOSITORY,
 447                            OnlyEnabled::CHOICE_YES))
 448     return false;
 449
 450   repoForDep = std::static_pointer_cast<CRepository>(tmp);
 451
 452   CLog::LogFC(LOGDEBUG, LOGADDONS, "found dependency [{}] for install/update from repo [{}]",
 453               dependencyToInstall->ID(), repoForDep->ID());
 454
 455   if (dependencyToInstall->HasType(AddonType::REPOSITORY))
 456   {
 457     CLog::LogFC(LOGDEBUG, LOGADDONS,
 458                 "dependency with id [{}] has type ADDON_REPOSITORY and will not install!",
 459                 dependencyToInstall->ID());
 460
 461     return false;
 462   }
 463
 464   return true;
 465 }
 466
 467 bool CAddonRepos::FindDependencyByParentRepo(const std::string& dependsId,
 468                                              const std::string& parentRepoId,
 469                                              std::shared_ptr<IAddon>& dependencyToInstall) const
 470 {
 471   const auto repoEntryIt = m_latestVersionsByRepo.find(parentRepoId);
 472   if (repoEntryIt != m_latestVersionsByRepo.end())
 473   {
 474     if (GetLatestVersionByMap(dependsId, repoEntryIt->second, dependencyToInstall))
 475       return true;
 476   }
 477
 478   return false;
 479 }
 480
 481 void CAddonRepos::BuildCompatibleVersionsList(
 482     std::vector<std::shared_ptr<IAddon>>& compatibleVersions) const
 483 {
 484   std::vector<std::shared_ptr<IAddon>> officialVersions;
 485   std::vector<std::shared_ptr<IAddon>> privateVersions;
 486
 487   for (const auto& addon : m_allAddons)
 488   {
 489     if (m_addonMgr.IsCompatible(addon))
 490     {
 491       if (IsFromOfficialRepo(addon, CheckAddonPath::CHOICE_YES))
 492       {
 493         officialVersions.emplace_back(addon);
 494       }
 495       else
 496       {
 497         privateVersions.emplace_back(addon);
 498       }
 499     }
 500   }
 501
 502   auto comparator = [](const std::shared_ptr<IAddon>& a, const std::shared_ptr<IAddon>& b) {
 503     return (a->Version() > b->Version());
 504   };
 505
 506   std::sort(officialVersions.begin(), officialVersions.end(), comparator);
 507   std::sort(privateVersions.begin(), privateVersions.end(), comparator);
 508
 509   compatibleVersions = std::move(officialVersions);
 510   std::move(privateVersions.begin(), privateVersions.end(), std::back_inserter(compatibleVersions));
 511 }