xbmc/addons/gui/GUIDialogAddonInfo.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 "GUIDialogAddonInfo.h"
  10
  11 #include "FileItem.h"
  12 #include "FileItemList.h"
  13 #include "GUIPassword.h"
  14 #include "ServiceBroker.h"
  15 #include "Util.h"
  16 #include "addons/AddonDatabase.h"
  17 #include "addons/AddonInstaller.h"
  18 #include "addons/AddonManager.h"
  19 #include "addons/AddonRepos.h"
  20 #include "addons/AddonSystemSettings.h"
  21 #include "addons/AudioDecoder.h"
  22 #include "addons/ExtsMimeSupportList.h"
  23 #include "addons/IAddon.h"
  24 #include "addons/addoninfo/AddonInfo.h"
  25 #include "addons/addoninfo/AddonType.h"
  26 #include "addons/gui/GUIDialogAddonSettings.h"
  27 #include "addons/gui/GUIHelpers.h"
  28 #include "dialogs/GUIDialogSelect.h"
  29 #include "dialogs/GUIDialogYesNo.h"
  30 #include "filesystem/Directory.h"
  31 #include "games/GameUtils.h"
  32 #include "guilib/GUIComponent.h"
  33 #include "guilib/GUIWindowManager.h"
  34 #include "guilib/LocalizeStrings.h"
  35 #include "input/actions/Action.h"
  36 #include "input/actions/ActionIDs.h"
  37 #include "interfaces/builtins/Builtins.h"
  38 #include "messaging/helpers/DialogOKHelper.h"
  39 #include "pictures/GUIWindowSlideShow.h"
  40 #include "settings/Settings.h"
  41 #include "settings/SettingsComponent.h"
  42 #include "utils/Digest.h"
  43 #include "utils/JobManager.h"
  44 #include "utils/StringUtils.h"
  45 #include "utils/Variant.h"
  46 #include "utils/log.h"
  47
  48 #include <functional>
  49 #include <memory>
  50 #include <sstream>
  51 #include <utility>
  52
  53 #define CONTROL_BTN_INSTALL 6
  54 #define CONTROL_BTN_ENABLE 7
  55 #define CONTROL_BTN_UPDATE 8
  56 #define CONTROL_BTN_SETTINGS 9
  57 #define CONTROL_BTN_DEPENDENCIES 10
  58 #define CONTROL_BTN_SELECT 12
  59 #define CONTROL_BTN_AUTOUPDATE 13
  60 #define CONTROL_BTN_VERSIONS 14
  61 #define CONTROL_LIST_SCREENSHOTS 50
  62
  63 using namespace KODI;
  64 using namespace ADDON;
  65 using namespace KODI::ADDONS;
  66 using namespace XFILE;
  67 using namespace KODI::MESSAGING;
  68
  69 CGUIDialogAddonInfo::CGUIDialogAddonInfo(void)
  70   : CGUIDialog(WINDOW_DIALOG_ADDON_INFO, "DialogAddonInfo.xml"),
  71     m_item(std::make_shared<CFileItem>())
  72 {
  73   m_loadType = KEEP_IN_MEMORY;
  74 }
  75
  76 CGUIDialogAddonInfo::~CGUIDialogAddonInfo(void) = default;
  77
  78 bool CGUIDialogAddonInfo::OnMessage(CGUIMessage& message)
  79 {
  80   switch (message.GetMessage())
  81   {
  82     case GUI_MSG_CLICKED:
  83     {
  84       int iControl = message.GetSenderId();
  85       if (iControl == CONTROL_BTN_UPDATE)
  86       {
  87         OnUpdate();
  88         return true;
  89       }
  90       else if (iControl == CONTROL_BTN_INSTALL)
  91       {
  92         const auto& itemAddonInfo = m_item->GetAddonInfo();
  93         if (!CServiceBroker::GetAddonMgr().IsAddonInstalled(
  94                 itemAddonInfo->ID(), itemAddonInfo->Origin(), itemAddonInfo->Version()))
  95         {
  96           OnInstall();
  97           return true;
  98         }
  99         else
 100         {
 101           m_silentUninstall = false;
 102           OnUninstall();
 103           return true;
 104         }
 105       }
 106       else if (iControl == CONTROL_BTN_SELECT)
 107       {
 108         OnSelect();
 109         return true;
 110       }
 111       else if (iControl == CONTROL_BTN_ENABLE)
 112       {
 113         OnEnableDisable();
 114         return true;
 115       }
 116       else if (iControl == CONTROL_BTN_SETTINGS)
 117       {
 118         OnSettings();
 119         return true;
 120       }
 121       else if (iControl == CONTROL_BTN_DEPENDENCIES)
 122       {
 123         ShowDependencyList(Reactivate::CHOICE_YES, EntryPoint::SHOW_DEPENDENCIES);
 124         return true;
 125       }
 126       else if (iControl == CONTROL_BTN_AUTOUPDATE)
 127       {
 128         OnToggleAutoUpdates();
 129         return true;
 130       }
 131       else if (iControl == CONTROL_LIST_SCREENSHOTS)
 132       {
 133         if (message.GetParam1() == ACTION_SELECT_ITEM ||
 134             message.GetParam1() == ACTION_MOUSE_LEFT_CLICK)
 135         {
 136           CGUIMessage msg(GUI_MSG_ITEM_SELECTED, GetID(), iControl);
 137           OnMessage(msg);
 138           int start = msg.GetParam1();
 139           if (start >= 0 && start < static_cast<int>(m_item->GetAddonInfo()->Screenshots().size()))
 140             CGUIWindowSlideShow::RunSlideShow(m_item->GetAddonInfo()->Screenshots(), start);
 141         }
 142       }
 143       else if (iControl == CONTROL_BTN_VERSIONS)
 144       {
 145         OnSelectVersion();
 146         return true;
 147       }
 148     }
 149     break;
 150     default:
 151       break;
 152   }
 153
 154   return CGUIDialog::OnMessage(message);
 155 }
 156
 157 bool CGUIDialogAddonInfo::OnAction(const CAction& action)
 158 {
 159   if (action.GetID() == ACTION_SHOW_INFO)
 160   {
 161     Close();
 162     return true;
 163   }
 164   return CGUIDialog::OnAction(action);
 165 }
 166
 167 void CGUIDialogAddonInfo::OnInitWindow()
 168 {
 169   CGUIDialog::OnInitWindow();
 170   BuildDependencyList();
 171   UpdateControls(PerformButtonFocus::CHOICE_YES);
 172 }
 173
 174 void CGUIDialogAddonInfo::UpdateControls(PerformButtonFocus performButtonFocus)
 175 {
 176   if (!m_item)
 177     return;
 178
 179   const auto& itemAddonInfo = m_item->GetAddonInfo();
 180   bool isInstalled = CServiceBroker::GetAddonMgr().IsAddonInstalled(
 181       itemAddonInfo->ID(), itemAddonInfo->Origin(), itemAddonInfo->Version());
 182   m_addonEnabled =
 183       m_localAddon && !CServiceBroker::GetAddonMgr().IsAddonDisabled(m_localAddon->ID());
 184   bool canDisable =
 185       isInstalled && CServiceBroker::GetAddonMgr().CanAddonBeDisabled(m_localAddon->ID());
 186   bool canInstall = !isInstalled && itemAddonInfo->LifecycleState() != AddonLifecycleState::BROKEN;
 187   bool canUninstall = m_localAddon && CServiceBroker::GetAddonMgr().CanUninstall(m_localAddon);
 188
 189   bool isUpdate = (!isInstalled && CServiceBroker::GetAddonMgr().IsAddonInstalled(
 190                                        itemAddonInfo->ID(), itemAddonInfo->Origin()));
 191
 192   bool showUpdateButton = m_localAddon &&
 193                           CServiceBroker::GetAddonMgr().IsAutoUpdateable(m_localAddon->ID()) &&
 194                           m_item->GetProperty("Addon.HasUpdate").asBoolean();
 195
 196   if (isInstalled)
 197   {
 198     SET_CONTROL_LABEL(CONTROL_BTN_INSTALL, 24037); // uninstall
 199     CONTROL_ENABLE_ON_CONDITION(CONTROL_BTN_INSTALL, canUninstall);
 200   }
 201   else
 202   {
 203     if (isUpdate)
 204     {
 205       SET_CONTROL_LABEL(CONTROL_BTN_INSTALL, 24138); // update
 206     }
 207     else
 208     {
 209       SET_CONTROL_LABEL(CONTROL_BTN_INSTALL, 24038); // install
 210     }
 211
 212     CONTROL_ENABLE_ON_CONDITION(CONTROL_BTN_INSTALL, canInstall);
 213     if (canInstall && performButtonFocus == PerformButtonFocus::CHOICE_YES)
 214     {
 215       SET_CONTROL_FOCUS(CONTROL_BTN_INSTALL, 0);
 216     }
 217   }
 218
 219   if (showUpdateButton)
 220   {
 221     SET_CONTROL_VISIBLE(CONTROL_BTN_UPDATE);
 222     SET_CONTROL_HIDDEN(CONTROL_BTN_VERSIONS);
 223   }
 224   else
 225   {
 226     SET_CONTROL_VISIBLE(CONTROL_BTN_VERSIONS);
 227     SET_CONTROL_HIDDEN(CONTROL_BTN_UPDATE);
 228   }
 229
 230   if (m_addonEnabled)
 231   {
 232     SET_CONTROL_LABEL(CONTROL_BTN_ENABLE, 24021);
 233     CONTROL_ENABLE_ON_CONDITION(CONTROL_BTN_ENABLE, canDisable);
 234   }
 235   else
 236   {
 237     SET_CONTROL_LABEL(CONTROL_BTN_ENABLE, 24022);
 238     CONTROL_ENABLE_ON_CONDITION(CONTROL_BTN_ENABLE, isInstalled);
 239   }
 240
 241   bool autoUpdatesOn = CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
 242                            CSettings::SETTING_ADDONS_AUTOUPDATES) == AUTO_UPDATES_ON;
 243   CONTROL_ENABLE_ON_CONDITION(CONTROL_BTN_AUTOUPDATE, isInstalled && autoUpdatesOn);
 244   SET_CONTROL_SELECTED(GetID(), CONTROL_BTN_AUTOUPDATE,
 245                        isInstalled && autoUpdatesOn &&
 246                            CServiceBroker::GetAddonMgr().IsAutoUpdateable(m_localAddon->ID()));
 247   SET_CONTROL_LABEL(CONTROL_BTN_AUTOUPDATE, 21340);
 248
 249   const bool active = m_localAddon && CAddonSystemSettings::GetInstance().IsActive(*m_localAddon);
 250   CONTROL_ENABLE_ON_CONDITION(
 251       CONTROL_BTN_SELECT,
 252       m_addonEnabled && (CanShowSupportList() || CanOpen() || CanRun() || (CanUse() && !active)));
 253
 254   int label;
 255   if (CanShowSupportList())
 256     label = 21484;
 257   else if (CanUse())
 258     label = 21480;
 259   else if (CanOpen())
 260     label = 21478;
 261   else
 262     label = 21479;
 263   SET_CONTROL_LABEL(CONTROL_BTN_SELECT, label);
 264
 265   const bool hasSettings = m_localAddon && m_localAddon->CanHaveAddonOrInstanceSettings();
 266   CONTROL_ENABLE_ON_CONDITION(CONTROL_BTN_SETTINGS, isInstalled && hasSettings);
 267   if (isInstalled && hasSettings && performButtonFocus == PerformButtonFocus::CHOICE_YES)
 268   {
 269     SET_CONTROL_FOCUS(CONTROL_BTN_SETTINGS, 0);
 270   }
 271
 272   CONTROL_ENABLE_ON_CONDITION(CONTROL_BTN_DEPENDENCIES, !m_depsInstalledWithAvailable.empty());
 273
 274   CFileItemList items;
 275   for (const auto& screenshot : m_item->GetAddonInfo()->Screenshots())
 276   {
 277     auto item = std::make_shared<CFileItem>("");
 278     item->SetArt("thumb", screenshot);
 279     items.Add(std::move(item));
 280   }
 281   CGUIMessage msg(GUI_MSG_LABEL_BIND, GetID(), CONTROL_LIST_SCREENSHOTS, 0, 0, &items);
 282   OnMessage(msg);
 283 }
 284
 285 static const std::string LOCAL_CACHE =
 286     "\\0_local_cache"; // \0 to give it the lowest priority when sorting
 287
 288 int CGUIDialogAddonInfo::AskForVersion(std::vector<std::pair<CAddonVersion, std::string>>& versions)
 289 {
 290   auto dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(
 291       WINDOW_DIALOG_SELECT);
 292   dialog->Reset();
 293   dialog->SetHeading(CVariant{21338});
 294   dialog->SetUseDetails(true);
 295
 296   for (const auto& versionInfo : versions)
 297   {
 298     CFileItem item(StringUtils::Format(g_localizeStrings.Get(21339), versionInfo.first.asString()));
 299     if (m_localAddon && m_localAddon->Version() == versionInfo.first &&
 300         m_item->GetAddonInfo()->Origin() == versionInfo.second)
 301       item.Select(true);
 302
 303     AddonPtr repo;
 304     if (versionInfo.second == LOCAL_CACHE)
 305     {
 306       item.SetLabel2(g_localizeStrings.Get(24095));
 307       item.SetArt("icon", "DefaultAddonRepository.png");
 308       dialog->Add(item);
 309     }
 310     else if (CServiceBroker::GetAddonMgr().GetAddon(versionInfo.second, repo, AddonType::REPOSITORY,
 311                                                     OnlyEnabled::CHOICE_YES))
 312     {
 313       item.SetLabel2(repo->Name());
 314       item.SetArt("icon", repo->Icon());
 315       dialog->Add(item);
 316     }
 317   }
 318
 319   dialog->Open();
 320   return dialog->IsConfirmed() ? dialog->GetSelectedItem() : -1;
 321 }
 322
 323 void CGUIDialogAddonInfo::OnUpdate()
 324 {
 325   const auto& itemAddonInfo = m_item->GetAddonInfo();
 326   const std::string& addonId = itemAddonInfo->ID();
 327   const std::string& origin = m_item->GetProperty("Addon.ValidUpdateOrigin").asString();
 328   const CAddonVersion& version =
 329       static_cast<CAddonVersion>(m_item->GetProperty("Addon.ValidUpdateVersion").asString());
 330
 331   Close();
 332   if (!m_depsInstalledWithAvailable.empty() &&
 333       !ShowDependencyList(Reactivate::CHOICE_NO, EntryPoint::UPDATE))
 334     return;
 335
 336   CAddonInstaller::GetInstance().Install(addonId, version, origin);
 337 }
 338
 339 void CGUIDialogAddonInfo::OnSelectVersion()
 340 {
 341   if (!m_item->HasAddonInfo())
 342     return;
 343
 344   const std::string& processAddonId = m_item->GetAddonInfo()->ID();
 345   EntryPoint entryPoint = m_localAddon ? EntryPoint::UPDATE : EntryPoint::INSTALL;
 346
 347   // get all compatible versions of an addon-id regardless of their origin
 348   std::vector<std::shared_ptr<IAddon>> compatibleVersions =
 349       CServiceBroker::GetAddonMgr().GetCompatibleVersions(processAddonId);
 350
 351   std::vector<std::pair<CAddonVersion, std::string>> versions;
 352   versions.reserve(compatibleVersions.size());
 353
 354   for (const auto& compatibleVersion : compatibleVersions)
 355     versions.emplace_back(compatibleVersion->Version(), compatibleVersion->Origin());
 356
 357   CAddonDatabase database;
 358   database.Open();
 359
 360   CFileItemList items;
 361   if (XFILE::CDirectory::GetDirectory("special://home/addons/packages/", items, ".zip",
 362                                       DIR_FLAG_NO_FILE_DIRS))
 363   {
 364     for (int i = 0; i < items.Size(); ++i)
 365     {
 366       std::string packageId;
 367       std::string versionString;
 368       if (CAddonVersion::SplitFileName(packageId, versionString, items[i]->GetLabel()))
 369       {
 370         if (packageId == processAddonId)
 371         {
 372           std::string hash;
 373           std::string path(items[i]->GetPath());
 374           if (database.GetPackageHash(processAddonId, items[i]->GetPath(), hash))
 375           {
 376             std::string sha256 = CUtil::GetFileDigest(path, KODI::UTILITY::CDigest::Type::SHA256);
 377
 378             // don't offer locally cached packages that result in an invalid version.
 379             // usually this happens when the package filename gets malformed on the fs
 380             // e.g. downloading "http://localhost/a+b.zip" ends up in "a b.zip"
 381             const CAddonVersion version(versionString);
 382             if (StringUtils::EqualsNoCase(sha256, hash) && !version.empty())
 383               versions.emplace_back(version, LOCAL_CACHE);
 384           }
 385         }
 386       }
 387     }
 388   }
 389
 390   if (versions.empty())
 391     HELPERS::ShowOKDialogText(CVariant{21341}, CVariant{21342});
 392   else
 393   {
 394     int i = AskForVersion(versions);
 395     if (i != -1)
 396     {
 397       Close();
 398
 399       if (versions[i].second == LOCAL_CACHE)
 400       {
 401         CAddonInstaller::GetInstance().InstallFromZip(
 402             StringUtils::Format("special://home/addons/packages/{}-{}.zip", processAddonId,
 403                                 versions[i].first.asString()));
 404       }
 405       else
 406       {
 407         if (!m_depsInstalledWithAvailable.empty() &&
 408             !ShowDependencyList(Reactivate::CHOICE_NO, entryPoint))
 409           return;
 410         CAddonInstaller::GetInstance().Install(processAddonId, versions[i].first,
 411                                                versions[i].second);
 412       }
 413     }
 414   }
 415 }
 416
 417 void CGUIDialogAddonInfo::OnToggleAutoUpdates()
 418 {
 419   CGUIMessage msg(GUI_MSG_IS_SELECTED, GetID(), CONTROL_BTN_AUTOUPDATE);
 420   if (OnMessage(msg))
 421   {
 422     bool selected = msg.GetParam1() == 1;
 423     if (selected)
 424       CServiceBroker::GetAddonMgr().RemoveAllUpdateRulesFromList(m_localAddon->ID());
 425     else
 426       CServiceBroker::GetAddonMgr().AddUpdateRuleToList(m_localAddon->ID(),
 427                                                         AddonUpdateRule::USER_DISABLED_AUTO_UPDATE);
 428
 429     bool showUpdateButton = (selected && m_item->GetProperty("Addon.HasUpdate").asBoolean());
 430
 431     if (showUpdateButton)
 432     {
 433       SET_CONTROL_VISIBLE(CONTROL_BTN_UPDATE);
 434       SET_CONTROL_HIDDEN(CONTROL_BTN_VERSIONS);
 435     }
 436     else
 437     {
 438       SET_CONTROL_VISIBLE(CONTROL_BTN_VERSIONS);
 439       SET_CONTROL_HIDDEN(CONTROL_BTN_UPDATE);
 440     }
 441
 442     CServiceBroker::GetAddonMgr().PublishEventAutoUpdateStateChanged(m_localAddon->ID());
 443   }
 444 }
 445
 446 void CGUIDialogAddonInfo::OnInstall()
 447 {
 448   if (!g_passwordManager.CheckMenuLock(WINDOW_ADDON_BROWSER))
 449     return;
 450
 451   if (!m_item->HasAddonInfo())
 452     return;
 453
 454   const auto& itemAddonInfo = m_item->GetAddonInfo();
 455   const std::string& origin = itemAddonInfo->Origin();
 456
 457   if (m_localAddon && CAddonSystemSettings::GetInstance().GetAddonRepoUpdateMode() !=
 458                           AddonRepoUpdateMode::ANY_REPOSITORY)
 459   {
 460     if (m_localAddon->Origin() != origin && m_localAddon->Origin() != ORIGIN_SYSTEM)
 461     {
 462       const std::string& header = g_localizeStrings.Get(19098); // Warning!
 463       const std::string origin =
 464           !m_localAddon->Origin().empty() ? m_localAddon->Origin() : g_localizeStrings.Get(39029);
 465       const std::string text =
 466           StringUtils::Format(g_localizeStrings.Get(39028), m_localAddon->Name(), origin,
 467                               m_localAddon->Version().asString());
 468
 469       if (CGUIDialogYesNo::ShowAndGetInput(header, text))
 470       {
 471         m_silentUninstall = true;
 472         OnUninstall();
 473       }
 474       else
 475       {
 476         return;
 477       }
 478     }
 479   }
 480
 481   const std::string& addonId = itemAddonInfo->ID();
 482   const CAddonVersion& version = itemAddonInfo->Version();
 483
 484   Close();
 485   if (!m_depsInstalledWithAvailable.empty() &&
 486       !ShowDependencyList(Reactivate::CHOICE_NO, EntryPoint::INSTALL))
 487     return;
 488
 489   CAddonInstaller::GetInstance().Install(addonId, version, origin);
 490 }
 491
 492 void CGUIDialogAddonInfo::OnSelect()
 493 {
 494   if (!m_localAddon)
 495     return;
 496
 497   if (CanShowSupportList())
 498   {
 499     ShowSupportList();
 500     return;
 501   }
 502
 503   Close();
 504
 505   if (CanOpen() || CanRun())
 506     CBuiltins::GetInstance().Execute("RunAddon(" + m_localAddon->ID() + ")");
 507   else if (CanUse())
 508     CAddonSystemSettings::GetInstance().SetActive(m_localAddon->Type(), m_localAddon->ID());
 509 }
 510
 511 bool CGUIDialogAddonInfo::CanOpen() const
 512 {
 513   return m_localAddon && m_localAddon->Type() == AddonType::PLUGIN;
 514 }
 515
 516 bool CGUIDialogAddonInfo::CanRun() const
 517 {
 518   if (m_localAddon)
 519   {
 520     if (m_localAddon->Type() == AddonType::SCRIPT)
 521       return true;
 522
 523     if (GAME::CGameUtils::IsStandaloneGame(m_localAddon))
 524       return true;
 525   }
 526
 527   return false;
 528 }
 529
 530 bool CGUIDialogAddonInfo::CanUse() const
 531 {
 532   return m_localAddon && (m_localAddon->Type() == AddonType::SKIN ||
 533                           m_localAddon->Type() == AddonType::SCREENSAVER ||
 534                           m_localAddon->Type() == AddonType::VISUALIZATION ||
 535                           m_localAddon->Type() == AddonType::SCRIPT_WEATHER ||
 536                           m_localAddon->Type() == AddonType::RESOURCE_LANGUAGE ||
 537                           m_localAddon->Type() == AddonType::RESOURCE_UISOUNDS ||
 538                           m_localAddon->Type() == AddonType::AUDIOENCODER);
 539 }
 540
 541 bool CGUIDialogAddonInfo::CanShowSupportList() const
 542 {
 543   return m_localAddon && (m_localAddon->Type() == AddonType::AUDIODECODER ||
 544                           m_localAddon->Type() == AddonType::IMAGEDECODER);
 545 }
 546
 547 bool CGUIDialogAddonInfo::PromptIfDependency(int heading, int line2)
 548 {
 549   if (!m_localAddon)
 550     return false;
 551
 552   VECADDONS addons;
 553   std::vector<std::string> deps;
 554   CServiceBroker::GetAddonMgr().GetAddons(addons);
 555   for (VECADDONS::const_iterator it = addons.begin(); it != addons.end(); ++it)
 556   {
 557     auto i =
 558         std::find_if((*it)->GetDependencies().begin(), (*it)->GetDependencies().end(),
 559                      [&](const DependencyInfo& other) { return other.id == m_localAddon->ID(); });
 560     if (i != (*it)->GetDependencies().end() && !i->optional) // non-optional dependency
 561       deps.push_back((*it)->Name());
 562   }
 563
 564   if (!deps.empty())
 565   {
 566     std::string line0 = StringUtils::Format(g_localizeStrings.Get(24046), m_localAddon->Name());
 567     std::string line1 = StringUtils::Join(deps, ", ");
 568     HELPERS::ShowOKDialogLines(CVariant{heading}, CVariant{std::move(line0)},
 569                                CVariant{std::move(line1)}, CVariant{line2});
 570     return true;
 571   }
 572   return false;
 573 }
 574
 575 void CGUIDialogAddonInfo::OnUninstall()
 576 {
 577   if (!m_localAddon.get())
 578     return;
 579
 580   if (!g_passwordManager.CheckMenuLock(WINDOW_ADDON_BROWSER))
 581     return;
 582
 583   // ensure the addon is not a dependency of other installed addons
 584   if (PromptIfDependency(24037, 24047))
 585     return;
 586
 587   // prompt user to be sure
 588   if (!m_silentUninstall && !CGUIDialogYesNo::ShowAndGetInput(CVariant{24037}, CVariant{750}))
 589     return;
 590
 591   bool removeData = false;
 592   if (CDirectory::Exists(m_localAddon->Profile()))
 593     removeData = CGUIDialogYesNo::ShowAndGetInput(CVariant{24037}, CVariant{39014});
 594
 595   CAddonInstaller::GetInstance().UnInstall(m_localAddon, removeData);
 596
 597   Close();
 598 }
 599
 600 void CGUIDialogAddonInfo::OnEnableDisable()
 601 {
 602   if (!m_localAddon)
 603     return;
 604
 605   if (!g_passwordManager.CheckMenuLock(WINDOW_ADDON_BROWSER))
 606     return;
 607
 608   if (m_addonEnabled)
 609   {
 610     if (PromptIfDependency(24075, 24091))
 611       return; //required. can't disable
 612
 613     CServiceBroker::GetAddonMgr().DisableAddon(m_localAddon->ID(), AddonDisabledReason::USER);
 614   }
 615   else
 616   {
 617     // Check user want to enable if lifecycle not normal
 618     if (!ADDON::GUI::CHelpers::DialogAddonLifecycleUseAsk(m_localAddon))
 619       return;
 620
 621     CServiceBroker::GetAddonMgr().EnableAddon(m_localAddon->ID());
 622   }
 623
 624   UpdateControls(PerformButtonFocus::CHOICE_NO);
 625 }
 626
 627 void CGUIDialogAddonInfo::OnSettings()
 628 {
 629   CGUIDialogAddonSettings::ShowForAddon(m_localAddon);
 630 }
 631
 632 bool CGUIDialogAddonInfo::ShowDependencyList(Reactivate reactivate, EntryPoint entryPoint)
 633 {
 634   if (entryPoint != EntryPoint::INSTALL || m_showDepDialogOnInstall)
 635   {
 636     auto pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(
 637         WINDOW_DIALOG_SELECT);
 638     CFileItemList items;
 639
 640     for (const auto& it : m_depsInstalledWithAvailable)
 641     {
 642       // All combinations of depAddon and localAddon validity are possible and information
 643       // must be displayed even when there is no depAddon.
 644       // info_addon is the add-on to take the information to display (name, icon) from. The
 645       // version in the repository is preferred because it might contain more recent data.
 646
 647       std::shared_ptr<IAddon> infoAddon = it.m_available ? it.m_available : it.m_installed;
 648
 649       if (infoAddon)
 650       {
 651         if (entryPoint != EntryPoint::UPDATE || !it.IsInstalledUpToDate())
 652         {
 653           const CFileItemPtr item = std::make_shared<CFileItem>(infoAddon->Name());
 654           int messageId = 24180; // minversion only
 655
 656           // dep not installed locally, but it is available from a repo!
 657           // make sure only non-optional add-ons that meet versionMin are
 658           // announced for installation
 659
 660           if (!it.m_installed)
 661           {
 662             if (entryPoint != EntryPoint::SHOW_DEPENDENCIES && !it.m_depInfo.optional)
 663             {
 664               if (it.m_depInfo.versionMin <= it.m_available->Version())
 665               {
 666                 messageId = 24181; // => install
 667               }
 668               else
 669               {
 670                 messageId = 24185; // => not available, only lower versions available in the repos
 671               }
 672             }
 673           }
 674           else // dep is installed locally
 675           {
 676             messageId = 24182; // => installed
 677
 678             if (!it.IsInstalledUpToDate())
 679             {
 680               messageId = 24183; // => update to
 681             }
 682           }
 683
 684           if (entryPoint == EntryPoint::SHOW_DEPENDENCIES ||
 685               infoAddon->MainType() != AddonType::SCRIPT_MODULE ||
 686               !CAddonRepos::IsFromOfficialRepo(infoAddon, CheckAddonPath::CHOICE_NO))
 687           {
 688             item->SetLabel2(StringUtils::Format(
 689                 g_localizeStrings.Get(messageId), it.m_depInfo.versionMin.asString(),
 690                 it.m_installed ? it.m_installed->Version().asString() : "",
 691                 it.m_available ? it.m_available->Version().asString() : "",
 692                 it.m_depInfo.optional ? g_localizeStrings.Get(24184) : ""));
 693
 694             item->SetArt("icon", infoAddon->Icon());
 695             item->SetProperty("addon_id", it.m_depInfo.id);
 696             items.Add(item);
 697           }
 698         }
 699       }
 700       else
 701       {
 702         const CFileItemPtr item = std::make_shared<CFileItem>(it.m_depInfo.id);
 703         item->SetLabel2(g_localizeStrings.Get(10005)); // Not available
 704         items.Add(item);
 705       }
 706     }
 707
 708     if (!items.IsEmpty())
 709     {
 710       CFileItemPtr backup_item = GetCurrentListItem();
 711       while (true)
 712       {
 713         pDialog->Reset();
 714         pDialog->SetHeading(reactivate == Reactivate::CHOICE_YES ? 39024 : 39020);
 715         pDialog->SetUseDetails(true);
 716         for (auto& it : items)
 717           pDialog->Add(*it);
 718         pDialog->EnableButton(reactivate == Reactivate::CHOICE_NO, 186);
 719         pDialog->SetButtonFocus(true);
 720         pDialog->Open();
 721
 722         if (pDialog->IsButtonPressed())
 723           return true;
 724
 725         if (pDialog->IsConfirmed())
 726         {
 727           const CFileItemPtr& item = pDialog->GetSelectedFileItem();
 728           std::string addon_id = item->GetProperty("addon_id").asString();
 729           std::shared_ptr<IAddon> depAddon;
 730           if (CServiceBroker::GetAddonMgr().FindInstallableById(addon_id, depAddon))
 731           {
 732             Close();
 733             ShowForItem(std::make_shared<CFileItem>(depAddon));
 734           }
 735         }
 736         else
 737           break;
 738       }
 739       SetItem(backup_item);
 740       if (reactivate == Reactivate::CHOICE_YES)
 741         Open();
 742
 743       return false;
 744     }
 745   }
 746
 747   return true;
 748 }
 749
 750 void CGUIDialogAddonInfo::ShowSupportList()
 751 {
 752   std::vector<KODI::ADDONS::AddonSupportEntry> list;
 753   if (CanShowSupportList())
 754     list =
 755         CServiceBroker::GetExtsMimeSupportList().GetSupportedExtsAndMimeTypes(m_localAddon->ID());
 756
 757   auto pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(
 758       WINDOW_DIALOG_SELECT);
 759   CFileItemList items;
 760   for (const auto& entry : list)
 761   {
 762     // Ignore included extension about track support
 763     if (StringUtils::EndsWith(entry.m_name, KODI_ADDON_AUDIODECODER_TRACK_EXT))
 764       continue;
 765
 766     std::string label;
 767     if (entry.m_type == AddonSupportType::Extension)
 768       label = StringUtils::Format(g_localizeStrings.Get(21346), entry.m_name);
 769     else if (entry.m_type == AddonSupportType::Mimetype)
 770       label = StringUtils::Format(g_localizeStrings.Get(21347), entry.m_name);
 771     else
 772       label = entry.m_name;
 773
 774     const CFileItemPtr item = std::make_shared<CFileItem>(label);
 775     item->SetLabel2(entry.m_description);
 776     if (!entry.m_icon.empty())
 777       item->SetArt("icon", entry.m_icon);
 778     else if (entry.m_type == AddonSupportType::Extension)
 779       item->SetArt("icon", "DefaultExtensionInfo.png");
 780     else if (entry.m_type == AddonSupportType::Mimetype)
 781       item->SetArt("icon", "DefaultMimetypeInfo.png");
 782     item->SetProperty("addon_id", m_localAddon->ID());
 783     items.Add(item);
 784   }
 785
 786   pDialog->Reset();
 787   pDialog->SetHeading(21485);
 788   pDialog->SetUseDetails(true);
 789   for (auto& it : items)
 790     pDialog->Add(*it);
 791   pDialog->SetButtonFocus(true);
 792   pDialog->Open();
 793 }
 794
 795 bool CGUIDialogAddonInfo::ShowForItem(const CFileItemPtr& item)
 796 {
 797   if (!item)
 798     return false;
 799
 800   CGUIDialogAddonInfo* dialog =
 801       CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogAddonInfo>(
 802           WINDOW_DIALOG_ADDON_INFO);
 803   if (!dialog)
 804     return false;
 805   if (!dialog->SetItem(item))
 806     return false;
 807
 808   dialog->Open();
 809   return true;
 810 }
 811
 812 bool CGUIDialogAddonInfo::SetItem(const CFileItemPtr& item)
 813 {
 814   if (!item || !item->HasAddonInfo())
 815     return false;
 816
 817   m_item = std::make_shared<CFileItem>(*item);
 818   m_localAddon.reset();
 819   if (CServiceBroker::GetAddonMgr().GetAddon(item->GetAddonInfo()->ID(), m_localAddon,
 820                                              OnlyEnabled::CHOICE_NO))
 821   {
 822     CLog::Log(LOGDEBUG, "{} - Addon with id {} not found locally.", __FUNCTION__,
 823               item->GetAddonInfo()->ID());
 824   }
 825   return true;
 826 }
 827
 828 void CGUIDialogAddonInfo::BuildDependencyList()
 829 {
 830   if (!m_item)
 831     return;
 832
 833   m_showDepDialogOnInstall = false;
 834   m_depsInstalledWithAvailable.clear();
 835   m_deps = CServiceBroker::GetAddonMgr().GetDepsRecursive(m_item->GetAddonInfo()->ID(),
 836                                                           OnlyEnabledRootAddon::CHOICE_NO);
 837
 838   for (const auto& dep : m_deps)
 839   {
 840     std::shared_ptr<IAddon> addonInstalled;
 841     std::shared_ptr<IAddon> addonAvailable;
 842
 843     // Find add-on in local installation
 844     if (!CServiceBroker::GetAddonMgr().GetAddon(dep.id, addonInstalled, OnlyEnabled::CHOICE_YES))
 845     {
 846       addonInstalled = nullptr;
 847     }
 848
 849     // Find add-on in repositories
 850     if (!CServiceBroker::GetAddonMgr().FindInstallableById(dep.id, addonAvailable))
 851     {
 852       addonAvailable = nullptr;
 853     }
 854
 855     if (!addonInstalled)
 856     {
 857
 858       // after pushing the install button the dependency install dialog
 859       // will be opened only if...
 860       // - dependencies are unavailable (for informational purposes) OR
 861       // - the dependency is not a script/module                     OR
 862       // - the script/module is not available at an official repo
 863       if (!addonAvailable || addonAvailable->MainType() != AddonType::SCRIPT_MODULE ||
 864           !CAddonRepos::IsFromOfficialRepo(addonAvailable, CheckAddonPath::CHOICE_NO))
 865       {
 866         m_showDepDialogOnInstall = true;
 867       }
 868     }
 869     else
 870     {
 871
 872       // only display dialog if updates for already installed dependencies will install
 873       if (addonAvailable && addonAvailable->Version() > addonInstalled->Version())
 874       {
 875         m_showDepDialogOnInstall = true;
 876       }
 877     }
 878
 879     m_depsInstalledWithAvailable.emplace_back(dep, addonInstalled, addonAvailable);
 880   }
 881
 882   std::sort(m_depsInstalledWithAvailable.begin(), m_depsInstalledWithAvailable.end(),
 883             [](const auto& a, const auto& b) {
 884               // 1. "not installed/available" go to the bottom first
 885               const bool depAInstalledOrAvailable =
 886                   a.m_installed != nullptr || a.m_available != nullptr;
 887               const bool depBInstalledOrAvailable =
 888                   b.m_installed != nullptr || b.m_available != nullptr;
 889
 890               if (depAInstalledOrAvailable != depBInstalledOrAvailable)
 891               {
 892                 return !depAInstalledOrAvailable;
 893               }
 894
 895               // 2. then optional add-ons to top
 896               if (a.m_depInfo.optional != b.m_depInfo.optional)
 897               {
 898                 return a.m_depInfo.optional;
 899               }
 900
 901               // 3. addon type asc, except scripts/modules at the bottom
 902               const std::shared_ptr<IAddon>& depA = a.m_installed ? a.m_installed : a.m_available;
 903               const std::shared_ptr<IAddon>& depB = b.m_installed ? b.m_installed : b.m_available;
 904
 905               if (depA && depB)
 906               {
 907                 const AddonType typeA = depA->MainType();
 908                 const AddonType typeB = depB->MainType();
 909                 if (typeA != typeB)
 910                 {
 911                   if ((typeA == AddonType::SCRIPT_MODULE) == (typeB == AddonType::SCRIPT_MODULE))
 912                   {
 913                     // both are scripts/modules or neither one is => sort by addon type asc
 914                     return typeA < typeB;
 915                   }
 916                   else
 917                   {
 918                     // At this point, either:
 919                     // A is script/module and B is not, or A is not script/module and B is.
 920                     // the script/module goes to the bottom
 921                     return typeA != AddonType::SCRIPT_MODULE;
 922                   }
 923                 }
 924               }
 925
 926               // 4. finally order by addon-id
 927               return a.m_depInfo.id < b.m_depInfo.id;
 928             });
 929 }
 930
 931 bool CInstalledWithAvailable::IsInstalledUpToDate() const
 932 {
 933   if (m_installed)
 934   {
 935     if (!m_available || m_available->Version() == m_installed->Version())
 936     {
 937       return true;
 938     }
 939   }
 940
 941   return false;
 942 }