xbmc/addons/Addon.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 "Addon.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "addons/AddonManager.h"
  13 #include "addons/RepositoryUpdater.h"
  14 #include "addons/addoninfo/AddonInfo.h"
  15 #include "addons/addoninfo/AddonType.h"
  16 #include "addons/settings/AddonSettings.h"
  17 #include "filesystem/Directory.h"
  18 #include "filesystem/File.h"
  19 #include "settings/Settings.h"
  20 #include "settings/lib/Setting.h"
  21 #include "utils/StringUtils.h"
  22 #include "utils/URIUtils.h"
  23 #include "utils/XMLUtils.h"
  24 #include "utils/log.h"
  25
  26 #include <algorithm>
  27 #include <ostream>
  28 #include <string.h>
  29 #include <utility>
  30 #include <vector>
  31
  32 #ifdef HAS_PYTHON
  33 #include "interfaces/python/XBPython.h"
  34 #endif
  35
  36 using XFILE::CDirectory;
  37 using XFILE::CFile;
  38
  39 namespace ADDON
  40 {
  41
  42 CAddon::CAddon(const AddonInfoPtr& addonInfo, AddonType addonType)
  43   : m_addonInfo(addonInfo),
  44     m_type(addonType == AddonType::UNKNOWN ? addonInfo->MainType() : addonType)
  45 {
  46 }
  47
  48 AddonType CAddon::MainType() const
  49 {
  50   return m_addonInfo->MainType();
  51 }
  52
  53 bool CAddon::HasType(AddonType type) const
  54 {
  55   return m_addonInfo->HasType(type);
  56 }
  57
  58 bool CAddon::HasMainType(AddonType type) const
  59 {
  60   return m_addonInfo->HasType(type, true);
  61 }
  62
  63 const CAddonType* CAddon::Type(AddonType type) const
  64 {
  65   return m_addonInfo->Type(type);
  66 }
  67
  68 std::string CAddon::ID() const
  69 {
  70   return m_addonInfo->ID();
  71 }
  72
  73 std::string CAddon::Name() const
  74 {
  75   return m_addonInfo->Name();
  76 }
  77
  78 bool CAddon::IsBinary() const
  79 {
  80   return m_addonInfo->IsBinary();
  81 }
  82
  83 CAddonVersion CAddon::Version() const
  84 {
  85   return m_addonInfo->Version();
  86 }
  87
  88 CAddonVersion CAddon::MinVersion() const
  89 {
  90   return m_addonInfo->MinVersion();
  91 }
  92
  93 std::string CAddon::Summary() const
  94 {
  95   return m_addonInfo->Summary();
  96 }
  97
  98 std::string CAddon::Description() const
  99 {
 100   return m_addonInfo->Description();
 101 }
 102
 103 std::string CAddon::Path() const
 104 {
 105   return m_addonInfo->Path();
 106 }
 107
 108 std::string CAddon::Profile() const
 109 {
 110   return m_addonInfo->ProfilePath();
 111 }
 112
 113 std::string CAddon::Author() const
 114 {
 115   return m_addonInfo->Author();
 116 }
 117
 118 std::string CAddon::ChangeLog() const
 119 {
 120   return m_addonInfo->ChangeLog();
 121 }
 122
 123 std::string CAddon::Icon() const
 124 {
 125   return m_addonInfo->Icon();
 126 }
 127
 128 ArtMap CAddon::Art() const
 129 {
 130   return m_addonInfo->Art();
 131 }
 132
 133 std::vector<std::string> CAddon::Screenshots() const
 134 {
 135   return m_addonInfo->Screenshots();
 136 }
 137
 138 std::string CAddon::Disclaimer() const
 139 {
 140   return m_addonInfo->Disclaimer();
 141 }
 142
 143 AddonLifecycleState CAddon::LifecycleState() const
 144 {
 145   return m_addonInfo->LifecycleState();
 146 }
 147
 148 std::string CAddon::LifecycleStateDescription() const
 149 {
 150   return m_addonInfo->LifecycleStateDescription();
 151 }
 152
 153 CDateTime CAddon::InstallDate() const
 154 {
 155   return m_addonInfo->InstallDate();
 156 }
 157
 158 CDateTime CAddon::LastUpdated() const
 159 {
 160   return m_addonInfo->LastUpdated();
 161 }
 162
 163 CDateTime CAddon::LastUsed() const
 164 {
 165   return m_addonInfo->LastUsed();
 166 }
 167
 168 std::string CAddon::Origin() const
 169 {
 170   return m_addonInfo->Origin();
 171 }
 172
 173 std::string CAddon::OriginName() const
 174 {
 175   return m_addonInfo->OriginName();
 176 }
 177
 178 uint64_t CAddon::PackageSize() const
 179 {
 180   return m_addonInfo->PackageSize();
 181 }
 182
 183 const InfoMap& CAddon::ExtraInfo() const
 184 {
 185   return m_addonInfo->ExtraInfo();
 186 }
 187
 188 const std::vector<DependencyInfo>& CAddon::GetDependencies() const
 189 {
 190   return m_addonInfo->GetDependencies();
 191 }
 192
 193 std::string CAddon::FanArt() const
 194 {
 195   auto it = m_addonInfo->Art().find("fanart");
 196   return it != m_addonInfo->Art().end() ? it->second : "";
 197 }
 198
 199 bool CAddon::MeetsVersion(const CAddonVersion& versionMin, const CAddonVersion& version) const
 200 {
 201   return m_addonInfo->MeetsVersion(versionMin, version);
 202 }
 203
 204 /**
 205  * Settings Handling
 206  */
 207
 208 std::vector<AddonInstanceId> CAddon::GetKnownInstanceIds() const
 209 {
 210   return m_addonInfo->GetKnownInstanceIds();
 211 }
 212
 213 bool CAddon::SupportsMultipleInstances() const
 214 {
 215   return m_addonInfo->SupportsMultipleInstances();
 216 }
 217
 218 AddonInstanceSupport CAddon::InstanceUseType() const
 219 {
 220   return m_addonInfo->InstanceUseType();
 221 }
 222
 223 bool CAddon::SupportsInstanceSettings() const
 224 {
 225   return m_addonInfo->SupportsInstanceSettings();
 226 }
 227
 228 bool CAddon::DeleteInstanceSettings(AddonInstanceId instance)
 229 {
 230   if (instance == ADDON_SETTINGS_ID)
 231     return false;
 232
 233   const auto itr = m_settings.find(instance);
 234   if (itr == m_settings.end())
 235     return false;
 236
 237   if (CFile::Exists(itr->second.m_userSettingsPath))
 238     CFile::Delete(itr->second.m_userSettingsPath);
 239
 240   ResetSettings(instance);
 241
 242   return true;
 243 }
 244
 245 bool CAddon::CanHaveAddonOrInstanceSettings()
 246 {
 247   return HasSettings(ADDON_SETTINGS_ID) || SupportsInstanceSettings();
 248 }
 249
 250 bool CAddon::HasSettings(AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 251 {
 252   return LoadSettings(false, true, id) && m_settings[id].m_addonSettings->HasSettings();
 253 }
 254
 255 bool CAddon::SettingsInitialized(AddonInstanceId id /* = ADDON_SETTINGS_ID */) const
 256 {
 257   const auto addonSettings = FindInstanceSettings(id);
 258   return addonSettings && addonSettings->IsInitialized();
 259 }
 260
 261 bool CAddon::SettingsLoaded(AddonInstanceId id /* = ADDON_SETTINGS_ID */) const
 262 {
 263   const auto addonSettings = FindInstanceSettings(id);
 264   return addonSettings && addonSettings->IsLoaded();
 265 }
 266
 267 bool CAddon::LoadSettings(bool bForce,
 268                           bool loadUserSettings,
 269                           AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 270 {
 271   if (SettingsInitialized(id) && !bForce)
 272     return true;
 273
 274   const auto itr = m_settings.find(id);
 275   if (itr != m_settings.end())
 276   {
 277     if (itr->second.m_loadSettingsFailed)
 278       return false;
 279   }
 280   else
 281   {
 282     InitSettings(id);
 283   }
 284
 285   // assume loading settings fails
 286   m_settings[id].m_loadSettingsFailed = true;
 287
 288   // reset the settings if we are forced to
 289   if (SettingsInitialized(id) && bForce)
 290     GetSettings(id)->Uninitialize();
 291
 292   // load the settings definition XML file
 293   const auto addonSettingsDefinitionFile = m_settings[id].m_addonSettingsPath;
 294   CXBMCTinyXML addonSettingsDefinitionDoc;
 295   if (!addonSettingsDefinitionDoc.LoadFile(addonSettingsDefinitionFile))
 296   {
 297     if (CFile::Exists(addonSettingsDefinitionFile))
 298     {
 299       CLog::Log(LOGERROR, "CAddon[{}]: unable to load: {}, Line {}\n{}", ID(),
 300                 addonSettingsDefinitionFile, addonSettingsDefinitionDoc.ErrorRow(),
 301                 addonSettingsDefinitionDoc.ErrorDesc());
 302     }
 303
 304     return false;
 305   }
 306
 307   // initialize the settings definition
 308   if (!GetSettings(id)->Initialize(addonSettingsDefinitionDoc))
 309   {
 310     CLog::Log(LOGERROR, "CAddon[{}]: failed to initialize addon settings", ID());
 311     return false;
 312   }
 313
 314   // loading settings didn't fail
 315   m_settings[id].m_loadSettingsFailed = false;
 316
 317   // load user settings / values
 318   if (loadUserSettings)
 319     LoadUserSettings(id);
 320
 321   return true;
 322 }
 323
 324 bool CAddon::HasUserSettings(AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 325 {
 326   if (!LoadSettings(false, true, id))
 327     return false;
 328
 329   return SettingsLoaded(id) && m_settings[id].m_hasUserSettings;
 330 }
 331
 332 bool CAddon::ReloadSettings(AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 333 {
 334   return LoadSettings(true, true, id);
 335 }
 336
 337 void CAddon::ResetSettings(AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 338 {
 339   m_settings.erase(id);
 340 }
 341
 342 bool CAddon::LoadUserSettings(AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 343 {
 344   if (!SettingsInitialized(id) && !InitSettings(id))
 345     return false;
 346
 347   CSettingsData& data = m_settings[id];
 348
 349   data.m_hasUserSettings = false;
 350
 351   // there are no user settings
 352   if (!CFile::Exists(data.m_userSettingsPath))
 353   {
 354     // mark the settings as loaded
 355     GetSettings(id)->SetLoaded();
 356     return true;
 357   }
 358
 359   CXBMCTinyXML doc;
 360   if (!doc.LoadFile(data.m_userSettingsPath))
 361   {
 362     CLog::Log(LOGERROR, "CAddon[{}]: failed to load addon settings from {}", ID(),
 363               data.m_userSettingsPath);
 364     return false;
 365   }
 366
 367   return SettingsFromXML(doc, false, id);
 368 }
 369
 370 bool CAddon::HasSettingsToSave(AddonInstanceId id /* = ADDON_SETTINGS_ID */) const
 371 {
 372   return SettingsLoaded(id);
 373 }
 374
 375 bool CAddon::SaveSettings(AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 376 {
 377   if (!HasSettingsToSave(id))
 378     return false; // no settings to save
 379
 380   bool success{true};
 381   CSettingsData& data = m_settings[id];
 382
 383   // break down the path into directories
 384   const std::string strAddon = URIUtils::GetDirectory(data.m_userSettingsPath);
 385   const std::string strRoot = URIUtils::GetDirectory(strAddon);
 386
 387   // create the individual folders
 388   if (!CDirectory::Exists(strRoot))
 389     success = CDirectory::Create(strRoot);
 390   if (!CDirectory::Exists(strAddon))
 391     success = CDirectory::Create(strAddon);
 392
 393   // create the XML file
 394   CXBMCTinyXML doc;
 395   if (SettingsToXML(doc, id))
 396     success = doc.SaveFile(data.m_userSettingsPath);
 397
 398   data.m_hasUserSettings = true;
 399
 400   //push the settings changes to the running addon instance
 401   CServiceBroker::GetAddonMgr().ReloadSettings(ID(), id);
 402 #ifdef HAS_PYTHON
 403   CServiceBroker::GetXBPython().OnSettingsChanged(ID());
 404 #endif
 405   return success;
 406 }
 407
 408 std::string CAddon::GetSetting(const std::string& key, AddonInstanceId id)
 409 {
 410   if (key.empty() || !LoadSettings(false, true, id))
 411     return ""; // no settings available
 412
 413   auto setting = m_settings[id].m_addonSettings->GetSetting(key);
 414   if (setting != nullptr)
 415     return setting->ToString();
 416
 417   return "";
 418 }
 419
 420 template<class TSetting>
 421 bool GetSettingValue(CAddon& addon,
 422                      AddonInstanceId instanceId,
 423                      const std::string& key,
 424                      typename TSetting::Value& value)
 425 {
 426   if (key.empty() || !addon.HasSettings(instanceId))
 427     return false;
 428
 429   auto setting = addon.GetSettings(instanceId)->GetSetting(key);
 430   if (setting == nullptr || setting->GetType() != TSetting::Type())
 431     return false;
 432
 433   value = std::static_pointer_cast<TSetting>(setting)->GetValue();
 434   return true;
 435 }
 436
 437 bool CAddon::GetSettingBool(const std::string& key,
 438                             bool& value,
 439                             AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 440 {
 441   return GetSettingValue<CSettingBool>(*this, id, key, value);
 442 }
 443
 444 bool CAddon::GetSettingInt(const std::string& key,
 445                            int& value,
 446                            AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 447 {
 448   return GetSettingValue<CSettingInt>(*this, id, key, value);
 449 }
 450
 451 bool CAddon::GetSettingNumber(const std::string& key,
 452                               double& value,
 453                               AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 454 {
 455   return GetSettingValue<CSettingNumber>(*this, id, key, value);
 456 }
 457
 458 bool CAddon::GetSettingString(const std::string& key,
 459                               std::string& value,
 460                               AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 461 {
 462   return GetSettingValue<CSettingString>(*this, id, key, value);
 463 }
 464
 465 void CAddon::UpdateSetting(const std::string& key,
 466                            const std::string& value,
 467                            AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 468 {
 469   if (key.empty() || !LoadSettings(false, true, id))
 470     return;
 471
 472   // try to get the setting
 473   auto setting = m_settings[id].m_addonSettings->GetSetting(key);
 474
 475   // if the setting doesn't exist, try to add it
 476   if (setting == nullptr)
 477   {
 478     setting = m_settings[id].m_addonSettings->AddSetting(key, value);
 479     if (setting == nullptr)
 480     {
 481       CLog::Log(LOGERROR, "CAddon[{}]: failed to add undefined setting \"{}\"", ID(), key);
 482       return;
 483     }
 484   }
 485
 486   setting->FromString(value);
 487 }
 488
 489 template<class TSetting>
 490 bool UpdateSettingValue(CAddon& addon,
 491                         AddonInstanceId instanceId,
 492                         const std::string& key,
 493                         typename TSetting::Value value)
 494 {
 495   if (key.empty() || !addon.HasSettings(instanceId))
 496     return false;
 497
 498   // try to get the setting
 499   auto setting = addon.GetSettings(instanceId)->GetSetting(key);
 500
 501   // if the setting doesn't exist, try to add it
 502   if (setting == nullptr)
 503   {
 504     setting = addon.GetSettings(instanceId)->AddSetting(key, value);
 505     if (setting == nullptr)
 506     {
 507       CLog::Log(LOGERROR, "CAddon[{}]: failed to add undefined setting \"{}\"", addon.ID(), key);
 508       return false;
 509     }
 510   }
 511
 512   if (setting->GetType() != TSetting::Type())
 513     return false;
 514
 515   return std::static_pointer_cast<TSetting>(setting)->SetValue(value);
 516 }
 517
 518 bool CAddon::UpdateSettingBool(const std::string& key,
 519                                bool value,
 520                                AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 521 {
 522   return UpdateSettingValue<CSettingBool>(*this, id, key, value);
 523 }
 524
 525 bool CAddon::UpdateSettingInt(const std::string& key,
 526                               int value,
 527                               AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 528 {
 529   return UpdateSettingValue<CSettingInt>(*this, id, key, value);
 530 }
 531
 532 bool CAddon::UpdateSettingNumber(const std::string& key,
 533                                  double value,
 534                                  AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 535 {
 536   return UpdateSettingValue<CSettingNumber>(*this, id, key, value);
 537 }
 538
 539 bool CAddon::UpdateSettingString(const std::string& key,
 540                                  const std::string& value,
 541                                  AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 542 {
 543   return UpdateSettingValue<CSettingString>(*this, id, key, value);
 544 }
 545
 546 bool CAddon::SettingsFromXML(const CXBMCTinyXML& doc,
 547                              bool loadDefaults,
 548                              AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 549 {
 550   if (doc.RootElement() == nullptr)
 551     return false;
 552
 553   // if the settings haven't been initialized yet, try it from the given XML
 554   if (!SettingsInitialized(id))
 555   {
 556     if (!GetSettings(id)->Initialize(doc))
 557     {
 558       CLog::Log(LOGERROR, "CAddon[{}]: failed to initialize addon settings", ID());
 559       return false;
 560     }
 561   }
 562
 563   // reset all setting values to their default value
 564   if (loadDefaults)
 565     GetSettings(id)->SetDefaults();
 566
 567   // try to load the setting's values from the given XML
 568   if (!GetSettings(id)->Load(doc))
 569   {
 570     CLog::Log(LOGERROR, "CAddon[{}]: failed to load user settings", ID());
 571     return false;
 572   }
 573
 574   m_settings[id].m_hasUserSettings = true;
 575
 576   return true;
 577 }
 578
 579 bool CAddon::SettingsToXML(CXBMCTinyXML& doc, AddonInstanceId id /* = ADDON_SETTINGS_ID */) const
 580 {
 581   if (!SettingsInitialized(id))
 582     return false;
 583
 584   if (!m_settings[id].m_addonSettings->Save(doc))
 585   {
 586     CLog::Log(LOGERROR, "CAddon[{}]: failed to save addon settings", ID());
 587     return false;
 588   }
 589
 590   return true;
 591 }
 592
 593 bool CAddon::InitSettings(AddonInstanceId id)
 594 {
 595   // initialize addon settings if necessary
 596   if (!FindInstanceSettings(id))
 597   {
 598     CSettingsData data;
 599
 600     data.m_addonSettings =
 601         std::make_shared<CAddonSettings>(enable_shared_from_this::shared_from_this(), id);
 602     if (id == ADDON_SETTINGS_ID)
 603     {
 604       data.m_addonSettingsPath =
 605           URIUtils::AddFileToFolder(m_addonInfo->Path(), "resources", "settings.xml");
 606       data.m_userSettingsPath = URIUtils::AddFileToFolder(Profile(), "settings.xml");
 607     }
 608     else
 609     {
 610       data.m_addonSettingsPath =
 611           URIUtils::AddFileToFolder(m_addonInfo->Path(), "resources", "instance-settings.xml");
 612       data.m_userSettingsPath =
 613           URIUtils::AddFileToFolder(Profile(), StringUtils::Format("instance-settings-{}.xml", id));
 614     }
 615
 616     m_settings[id] = std::move(data);
 617     return true;
 618   }
 619
 620   return false;
 621 }
 622
 623 std::shared_ptr<CAddonSettings> CAddon::FindInstanceSettings(AddonInstanceId id) const
 624 {
 625   const auto itr = m_settings.find(id);
 626   if (itr == m_settings.end())
 627     return nullptr;
 628
 629   return itr->second.m_addonSettings;
 630 }
 631
 632 std::shared_ptr<CAddonSettings> CAddon::GetSettings(AddonInstanceId id /* = ADDON_SETTINGS_ID */)
 633 {
 634   if (InitSettings(id))
 635     LoadSettings(false, true, id);
 636
 637   return m_settings[id].m_addonSettings;
 638 }
 639
 640 std::string CAddon::LibPath() const
 641 {
 642   // Get library related to given type on construction
 643   std::string libName = m_addonInfo->Type(m_type)->LibName();
 644   if (libName.empty())
 645   {
 646     // If not present fallback to master library
 647     libName = m_addonInfo->LibName();
 648     if (libName.empty())
 649       return "";
 650   }
 651   return URIUtils::AddFileToFolder(m_addonInfo->Path(), libName);
 652 }
 653
 654 CAddonVersion CAddon::GetDependencyVersion(const std::string& dependencyID) const
 655 {
 656   return m_addonInfo->DependencyVersion(dependencyID);
 657 }
 658
 659 void OnPreInstall(const AddonPtr& addon)
 660 {
 661   //Fallback to the pre-install callback in the addon.
 662   //! @bug If primary extension point have changed we're calling the wrong method.
 663   addon->OnPreInstall();
 664 }
 665
 666 void OnPostInstall(const AddonPtr& addon, bool update, bool modal)
 667 {
 668   addon->OnPostInstall(update, modal);
 669 }
 670
 671 void OnPreUnInstall(const AddonPtr& addon)
 672 {
 673   addon->OnPreUnInstall();
 674 }
 675
 676 void OnPostUnInstall(const AddonPtr& addon)
 677 {
 678   addon->OnPostUnInstall();
 679 }
 680
 681 } // namespace ADDON