xbmc/addons/ExtsMimeSupportList.cpp

   1 /*
   2  *  Copyright (C) 2013 Arne Morten Kvarving
   3  *
   4  *  SPDX-License-Identifier: GPL-2.0-or-later
   5  *  See LICENSES/README.md for more information.
   6  */
   7
   8 #include "ExtsMimeSupportList.h"
   9
  10 #include "ServiceBroker.h"
  11 #include "addons/AddonEvents.h"
  12 #include "addons/AddonManager.h"
  13 #include "addons/addoninfo/AddonInfo.h"
  14 #include "addons/addoninfo/AddonType.h"
  15 #include "addons/kodi-dev-kit/include/kodi/addon-instance/AudioDecoder.h"
  16 #include "guilib/LocalizeStrings.h"
  17 #include "utils/URIUtils.h"
  18 #include "utils/log.h"
  19
  20 #include <mutex>
  21
  22 using namespace ADDON;
  23 using namespace KODI::ADDONS;
  24
  25 CExtsMimeSupportList::CExtsMimeSupportList(CAddonMgr& addonMgr) : m_addonMgr(addonMgr)
  26 {
  27   m_addonMgr.Events().Subscribe(this, &CExtsMimeSupportList::OnEvent);
  28
  29   // Load all available audio decoder addons during Kodi start
  30   const std::vector<AddonType> types = {AddonType::AUDIODECODER, AddonType::IMAGEDECODER};
  31   const auto addonInfos = m_addonMgr.GetAddonInfos(true, types);
  32   for (const auto& addonInfo : addonInfos)
  33     m_supportedList.emplace_back(ScanAddonProperties(addonInfo->MainType(), addonInfo));
  34 }
  35
  36 CExtsMimeSupportList::~CExtsMimeSupportList()
  37 {
  38   m_addonMgr.Events().Unsubscribe(this);
  39 }
  40
  41 void CExtsMimeSupportList::OnEvent(const AddonEvent& event)
  42 {
  43   if (typeid(event) == typeid(AddonEvents::Enabled) ||
  44       typeid(event) == typeid(AddonEvents::Disabled) ||
  45       typeid(event) == typeid(AddonEvents::ReInstalled))
  46   {
  47     if (m_addonMgr.HasType(event.addonId, AddonType::AUDIODECODER) ||
  48         m_addonMgr.HasType(event.addonId, AddonType::IMAGEDECODER))
  49       Update(event.addonId);
  50   }
  51   else if (typeid(event) == typeid(AddonEvents::UnInstalled))
  52   {
  53     Update(event.addonId);
  54   }
  55 }
  56
  57 void CExtsMimeSupportList::Update(const std::string& id)
  58 {
  59   // Stop used instance if present, otherwise the new becomes created on already created addon base one.
  60   {
  61     std::unique_lock<CCriticalSection> lock(m_critSection);
  62
  63     const auto itAddon =
  64         std::find_if(m_supportedList.begin(), m_supportedList.end(),
  65                      [&id](const SupportValues& addon) { return addon.m_addonInfo->ID() == id; });
  66
  67     if (itAddon != m_supportedList.end())
  68     {
  69       m_supportedList.erase(itAddon);
  70     }
  71   }
  72
  73   // Create and init the new addon instance
  74   std::shared_ptr<CAddonInfo> addonInfo = m_addonMgr.GetAddonInfo(id, AddonType::UNKNOWN);
  75   if (addonInfo && !m_addonMgr.IsAddonDisabled(id))
  76   {
  77     if (addonInfo->HasType(AddonType::AUDIODECODER) || addonInfo->HasType(AddonType::IMAGEDECODER))
  78     {
  79       SupportValues values = ScanAddonProperties(addonInfo->MainType(), addonInfo);
  80       {
  81         std::unique_lock<CCriticalSection> lock(m_critSection);
  82         m_supportedList.emplace_back(values);
  83       }
  84     }
  85   }
  86 }
  87
  88 CExtsMimeSupportList::SupportValues CExtsMimeSupportList::ScanAddonProperties(
  89     AddonType type, const std::shared_ptr<CAddonInfo>& addonInfo)
  90 {
  91   SupportValues values;
  92
  93   values.m_addonType = type;
  94   values.m_addonInfo = addonInfo;
  95   if (type == AddonType::AUDIODECODER)
  96   {
  97     values.m_codecName = addonInfo->Type(type)->GetValue("@name").asString();
  98     values.m_hasTags = addonInfo->Type(type)->GetValue("@tags").asBoolean();
  99     values.m_hasTracks = addonInfo->Type(type)->GetValue("@tracks").asBoolean();
 100   }
 101
 102   const auto support = addonInfo->Type(type)->GetElement("support");
 103   if (support)
 104   {
 105     // Scan here about complete defined xml groups with description and maybe icon
 106     // e.g.
 107     // `<extension name=".zwdsp">`
 108     // `  <description>30246</description>`
 109     // `</extension>`
 110     for (const auto& i : support->GetElements())
 111     {
 112       std::string name = i.second.GetValue("@name").asString();
 113       if (name.empty())
 114         continue;
 115
 116       const int description = i.second.GetValue("description").asInteger();
 117       const std::string icon =
 118           !i.second.GetValue("icon").empty()
 119               ? URIUtils::AddFileToFolder(addonInfo->Path(), i.second.GetValue("icon").asString())
 120               : "";
 121
 122       if (i.first == "extension")
 123       {
 124         if (name[0] != '.')
 125           name.insert(name.begin(), '.');
 126         values.m_supportedExtensions.emplace(name, SupportValue(description, icon));
 127       }
 128       else if (i.first == "mimetype")
 129       {
 130         values.m_supportedMimetypes.emplace(name, SupportValue(description, icon));
 131         const std::string extension = i.second.GetValue("extension").asString();
 132         if (!extension.empty())
 133           values.m_supportedExtensions.emplace(extension, SupportValue(description, icon));
 134       }
 135     }
 136
 137     // Scan here about small defined xml groups without anything
 138     // e.g. `<extension name=".adp"/>`
 139     for (const auto& i : support->GetValues())
 140     {
 141       for (const auto& j : i.second)
 142       {
 143         std::string name = j.second.asString();
 144         if (j.first == "extension@name")
 145         {
 146           if (name[0] != '.')
 147             name.insert(name.begin(), '.');
 148           values.m_supportedExtensions.emplace(name, SupportValue(-1, ""));
 149         }
 150         else if (j.first == "mimetype@name")
 151           values.m_supportedMimetypes.emplace(name, SupportValue(-1, ""));
 152       }
 153     }
 154   }
 155
 156   // Check addons support tracks, if yes add extension about related entry names
 157   // By them addon no more need to add itself on his addon.xml
 158   if (values.m_hasTracks)
 159     values.m_supportedExtensions.emplace(
 160         "." + values.m_codecName + KODI_ADDON_AUDIODECODER_TRACK_EXT, SupportValue(-1, ""));
 161
 162
 163   return values;
 164 }
 165
 166 std::vector<CExtsMimeSupportList::SupportValues> CExtsMimeSupportList::GetSupportedAddonInfos(
 167     FilterSelect select)
 168 {
 169   std::vector<SupportValues> addonInfos;
 170
 171   std::unique_lock<CCriticalSection> lock(m_critSection);
 172
 173   for (const auto& entry : m_supportedList)
 174   {
 175     if (select == FilterSelect::all || (select == FilterSelect::hasTags && entry.m_hasTags) ||
 176         (select == FilterSelect::hasTracks && entry.m_hasTracks))
 177       addonInfos.emplace_back(entry);
 178   }
 179
 180   return addonInfos;
 181 }
 182
 183 bool CExtsMimeSupportList::IsExtensionSupported(const std::string& ext)
 184 {
 185   std::unique_lock<CCriticalSection> lock(m_critSection);
 186
 187   for (const auto& entry : m_supportedList)
 188   {
 189     const auto it = std::find_if(
 190         entry.m_supportedExtensions.begin(), entry.m_supportedExtensions.end(),
 191         [ext](const std::pair<std::string, SupportValue>& v) { return v.first == ext; });
 192     if (it != entry.m_supportedExtensions.end())
 193       return true;
 194   }
 195
 196   return false;
 197 }
 198
 199 std::vector<std::pair<AddonType, std::shared_ptr<ADDON::CAddonInfo>>> CExtsMimeSupportList::
 200     GetExtensionSupportedAddonInfos(const std::string& ext, FilterSelect select)
 201 {
 202   std::vector<std::pair<AddonType, std::shared_ptr<CAddonInfo>>> addonInfos;
 203
 204   std::unique_lock<CCriticalSection> lock(m_critSection);
 205
 206   for (const auto& entry : m_supportedList)
 207   {
 208     const auto it = std::find_if(
 209         entry.m_supportedExtensions.begin(), entry.m_supportedExtensions.end(),
 210         [ext](const std::pair<std::string, SupportValue>& v) { return v.first == ext; });
 211     if (it != entry.m_supportedExtensions.end() &&
 212         (select == FilterSelect::all || (select == FilterSelect::hasTags && entry.m_hasTags) ||
 213          (select == FilterSelect::hasTracks && entry.m_hasTracks)))
 214       addonInfos.emplace_back(entry.m_addonType, entry.m_addonInfo);
 215   }
 216
 217   return addonInfos;
 218 }
 219
 220 bool CExtsMimeSupportList::IsMimetypeSupported(const std::string& mimetype)
 221 {
 222   std::unique_lock<CCriticalSection> lock(m_critSection);
 223
 224   for (const auto& entry : m_supportedList)
 225   {
 226
 227     const auto it = std::find_if(
 228         entry.m_supportedMimetypes.begin(), entry.m_supportedMimetypes.end(),
 229         [mimetype](const std::pair<std::string, SupportValue>& v) { return v.first == mimetype; });
 230     if (it != entry.m_supportedMimetypes.end())
 231       return true;
 232   }
 233
 234   return false;
 235 }
 236
 237 std::vector<std::pair<AddonType, std::shared_ptr<CAddonInfo>>> CExtsMimeSupportList::
 238     GetMimetypeSupportedAddonInfos(const std::string& mimetype, FilterSelect select)
 239 {
 240   std::vector<std::pair<AddonType, std::shared_ptr<CAddonInfo>>> addonInfos;
 241
 242   std::unique_lock<CCriticalSection> lock(m_critSection);
 243
 244   for (const auto& entry : m_supportedList)
 245   {
 246     const auto it = std::find_if(
 247         entry.m_supportedMimetypes.begin(), entry.m_supportedMimetypes.end(),
 248         [mimetype](const std::pair<std::string, SupportValue>& v) { return v.first == mimetype; });
 249     if (it != entry.m_supportedMimetypes.end() &&
 250         (select == FilterSelect::all || (select == FilterSelect::hasTags && entry.m_hasTags) ||
 251          (select == FilterSelect::hasTracks && entry.m_hasTracks)))
 252       addonInfos.emplace_back(entry.m_addonType, entry.m_addonInfo);
 253   }
 254
 255   return addonInfos;
 256 }
 257
 258 std::vector<AddonSupportEntry> CExtsMimeSupportList::GetSupportedExtsAndMimeTypes(
 259     const std::string& addonId)
 260 {
 261   std::vector<AddonSupportEntry> list;
 262
 263   const auto it =
 264       std::find_if(m_supportedList.begin(), m_supportedList.end(),
 265                    [addonId](const SupportValues& v) { return v.m_addonInfo->ID() == addonId; });
 266   if (it == m_supportedList.end())
 267     return list;
 268
 269   for (const auto& entry : it->m_supportedExtensions)
 270   {
 271     AddonSupportEntry supportEntry;
 272     supportEntry.m_type = AddonSupportType::Extension;
 273     supportEntry.m_name = entry.first;
 274     supportEntry.m_description =
 275         g_localizeStrings.GetAddonString(addonId, entry.second.m_description);
 276     supportEntry.m_icon = entry.second.m_icon;
 277     list.emplace_back(supportEntry);
 278   }
 279   for (const auto& entry : it->m_supportedMimetypes)
 280   {
 281     AddonSupportEntry supportEntry;
 282     supportEntry.m_type = AddonSupportType::Mimetype;
 283     supportEntry.m_name = entry.first;
 284     supportEntry.m_description =
 285         g_localizeStrings.GetAddonString(addonId, entry.second.m_description);
 286     supportEntry.m_icon = entry.second.m_icon;
 287     list.emplace_back(supportEntry);
 288   }
 289
 290   return list;
 291 }