xbmc/addons/binary-addons/AddonInstanceHandler.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 "AddonInstanceHandler.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "addons/AddonVersion.h"
  13 #include "addons/binary-addons/AddonDll.h"
  14 #include "addons/binary-addons/BinaryAddonManager.h"
  15 #include "addons/interfaces/AddonBase.h"
  16 #include "addons/kodi-dev-kit/include/kodi/AddonBase.h"
  17 #include "addons/settings/AddonSettings.h"
  18 #include "filesystem/Directory.h"
  19 #include "filesystem/SpecialProtocol.h"
  20 #include "settings/lib/Setting.h"
  21 #include "utils/StringUtils.h"
  22 #include "utils/log.h"
  23
  24 #include <mutex>
  25
  26 namespace ADDON
  27 {
  28
  29 CCriticalSection IAddonInstanceHandler::m_cdSec;
  30
  31 IAddonInstanceHandler::IAddonInstanceHandler(
  32     ADDON_TYPE type,
  33     const AddonInfoPtr& addonInfo,
  34     AddonInstanceId instanceId /* = ADDON_INSTANCE_ID_UNUSED */,
  35     KODI_HANDLE parentInstance /* = nullptr*/,
  36     const std::string& uniqueWorkID /* = ""*/)
  37   : m_type(type), m_instanceId(instanceId), m_parentInstance(parentInstance), m_addonInfo(addonInfo)
  38 {
  39   // if no special instance ID is given generate one from class pointer (is
  40   // faster as unique id and also safe enough for them).
  41   m_uniqueWorkID = !uniqueWorkID.empty() ? uniqueWorkID : StringUtils::Format("{}", fmt::ptr(this));
  42   m_addonBase = CServiceBroker::GetBinaryAddonManager().GetAddonBase(addonInfo, this, m_addon);
  43
  44   KODI_ADDON_INSTANCE_INFO* info = new KODI_ADDON_INSTANCE_INFO();
  45   info->number = m_instanceId; // @todo change within next big API change to "instance_id"
  46   info->id = m_uniqueWorkID.c_str(); // @todo change within next big API change to "unique_work_id"
  47   info->version = kodi::addon::GetTypeVersion(m_type);
  48   info->type = m_type;
  49   info->kodi = this;
  50   info->parent = m_parentInstance;
  51   info->first_instance = m_addon && !m_addon->Initialized();
  52   info->functions = new KODI_ADDON_INSTANCE_FUNC_CB();
  53   info->functions->get_instance_user_path = get_instance_user_path;
  54   info->functions->is_instance_setting_using_default = is_instance_setting_using_default;
  55   info->functions->get_instance_setting_bool = get_instance_setting_bool;
  56   info->functions->get_instance_setting_int = get_instance_setting_int;
  57   info->functions->get_instance_setting_float = get_instance_setting_float;
  58   info->functions->get_instance_setting_string = get_instance_setting_string;
  59   info->functions->set_instance_setting_bool = set_instance_setting_bool;
  60   info->functions->set_instance_setting_int = set_instance_setting_int;
  61   info->functions->set_instance_setting_float = set_instance_setting_float;
  62   info->functions->set_instance_setting_string = set_instance_setting_string;
  63   m_ifc.info = info;
  64   m_ifc.functions = new KODI_ADDON_INSTANCE_FUNC();
  65 }
  66
  67 IAddonInstanceHandler::~IAddonInstanceHandler()
  68 {
  69   CServiceBroker::GetBinaryAddonManager().ReleaseAddonBase(m_addonBase, this);
  70
  71   delete m_ifc.functions;
  72   if (m_ifc.info)
  73     delete m_ifc.info->functions;
  74   delete m_ifc.info;
  75 }
  76
  77 std::string IAddonInstanceHandler::ID() const
  78 {
  79   return m_addon ? m_addon->ID() : "";
  80 }
  81
  82 std::string IAddonInstanceHandler::Name() const
  83 {
  84   return m_addon ? m_addon->Name() : "";
  85 }
  86
  87 std::string IAddonInstanceHandler::Author() const
  88 {
  89   return m_addon ? m_addon->Author() : "";
  90 }
  91
  92 std::string IAddonInstanceHandler::Icon() const
  93 {
  94   return m_addon ? m_addon->Icon() : "";
  95 }
  96
  97 std::string IAddonInstanceHandler::Path() const
  98 {
  99   return m_addon ? m_addon->Path() : "";
 100 }
 101
 102 std::string IAddonInstanceHandler::Profile() const
 103 {
 104   return m_addon ? m_addon->Profile() : "";
 105 }
 106
 107 CAddonVersion IAddonInstanceHandler::Version() const
 108 {
 109   return m_addon ? m_addon->Version() : CAddonVersion();
 110 }
 111
 112 ADDON_STATUS IAddonInstanceHandler::CreateInstance()
 113 {
 114   if (!m_addon)
 115     return ADDON_STATUS_UNKNOWN;
 116
 117   std::unique_lock<CCriticalSection> lock(m_cdSec);
 118
 119   ADDON_STATUS status = m_addon->CreateInstance(&m_ifc);
 120   if (status != ADDON_STATUS_OK)
 121   {
 122     CLog::Log(LOGERROR,
 123               "IAddonInstanceHandler::{}: {} returned bad status \"{}\" during instance creation",
 124               __func__, m_addon->ID(), kodi::addon::TranslateAddonStatus(status));
 125   }
 126   return status;
 127 }
 128
 129 void IAddonInstanceHandler::DestroyInstance()
 130 {
 131   std::unique_lock<CCriticalSection> lock(m_cdSec);
 132   if (m_addon)
 133     m_addon->DestroyInstance(&m_ifc);
 134 }
 135
 136 std::shared_ptr<CSetting> IAddonInstanceHandler::GetSetting(const std::string& setting)
 137 {
 138   if (!m_addon->HasSettings(m_instanceId))
 139   {
 140     CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - couldn't get settings for add-on '{}'",
 141               __func__, Name());
 142     return nullptr;
 143   }
 144
 145   auto value = m_addon->GetSettings(m_instanceId)->GetSetting(setting);
 146   if (value == nullptr)
 147   {
 148     CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - can't find setting '{}' in '{}'", __func__,
 149               setting, Name());
 150     return nullptr;
 151   }
 152
 153   return value;
 154 }
 155
 156 char* IAddonInstanceHandler::get_instance_user_path(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl)
 157 {
 158   IAddonInstanceHandler* instance = static_cast<IAddonInstanceHandler*>(hdl);
 159   if (!instance)
 160     return nullptr;
 161
 162   const std::string path = CSpecialProtocol::TranslatePath(instance->m_addon->Profile());
 163
 164   XFILE::CDirectory::Create(path);
 165   return strdup(path.c_str());
 166 }
 167
 168 bool IAddonInstanceHandler::is_instance_setting_using_default(
 169     const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id)
 170 {
 171   IAddonInstanceHandler* instance = static_cast<IAddonInstanceHandler*>(hdl);
 172   if (!instance || !id)
 173     return false;
 174
 175   auto setting = instance->GetSetting(id);
 176   if (setting == nullptr)
 177     return false;
 178
 179   return setting->IsDefault();
 180 }
 181
 182 bool IAddonInstanceHandler::get_instance_setting_bool(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl,
 183                                                       const char* id,
 184                                                       bool* value)
 185 {
 186   IAddonInstanceHandler* instance = static_cast<IAddonInstanceHandler*>(hdl);
 187   if (!instance || !id || !value)
 188     return false;
 189
 190   auto setting = instance->GetSetting(id);
 191   if (setting == nullptr)
 192     return false;
 193
 194   if (setting->GetType() != SettingType::Boolean)
 195   {
 196     CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - setting '{}' is not a boolean in '{}'",
 197               __func__, id, instance->Name());
 198     return false;
 199   }
 200
 201   *value = std::static_pointer_cast<CSettingBool>(setting)->GetValue();
 202   return true;
 203 }
 204
 205 bool IAddonInstanceHandler::get_instance_setting_int(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl,
 206                                                      const char* id,
 207                                                      int* value)
 208 {
 209   IAddonInstanceHandler* instance = static_cast<IAddonInstanceHandler*>(hdl);
 210   if (!instance || !id || !value)
 211     return false;
 212
 213   auto setting = instance->GetSetting(id);
 214   if (setting == nullptr)
 215     return false;
 216
 217   if (setting->GetType() != SettingType::Integer && setting->GetType() != SettingType::Number)
 218   {
 219     CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - setting '{}' is not a integer in '{}'",
 220               __func__, id, instance->Name());
 221     return false;
 222   }
 223
 224   if (setting->GetType() == SettingType::Integer)
 225     *value = std::static_pointer_cast<CSettingInt>(setting)->GetValue();
 226   else
 227     *value = static_cast<int>(std::static_pointer_cast<CSettingNumber>(setting)->GetValue());
 228   return true;
 229 }
 230
 231 bool IAddonInstanceHandler::get_instance_setting_float(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl,
 232                                                        const char* id,
 233                                                        float* value)
 234 {
 235   IAddonInstanceHandler* instance = static_cast<IAddonInstanceHandler*>(hdl);
 236   if (!instance || !id || !value)
 237     return false;
 238
 239   auto setting = instance->GetSetting(id);
 240   if (setting == nullptr)
 241     return false;
 242
 243   if (setting->GetType() != SettingType::Number)
 244   {
 245     CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - setting '{}' is not a number in '{}'",
 246               __func__, id, instance->Name());
 247     return false;
 248   }
 249
 250   *value = static_cast<float>(std::static_pointer_cast<CSettingNumber>(setting)->GetValue());
 251   return true;
 252 }
 253
 254 bool IAddonInstanceHandler::get_instance_setting_string(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl,
 255                                                         const char* id,
 256                                                         char** value)
 257 {
 258   IAddonInstanceHandler* instance = static_cast<IAddonInstanceHandler*>(hdl);
 259   if (!instance || !id || !value)
 260     return false;
 261
 262   auto setting = instance->GetSetting(id);
 263   if (setting == nullptr)
 264     return false;
 265
 266   if (setting->GetType() != SettingType::String)
 267   {
 268     CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - setting '{}' is not a string in '{}'",
 269               __func__, id, instance->Name());
 270     return false;
 271   }
 272
 273   *value = strdup(std::static_pointer_cast<CSettingString>(setting)->GetValue().c_str());
 274   return true;
 275 }
 276
 277 bool IAddonInstanceHandler::set_instance_setting_bool(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl,
 278                                                       const char* id,
 279                                                       bool value)
 280 {
 281   IAddonInstanceHandler* instance = static_cast<IAddonInstanceHandler*>(hdl);
 282   if (!instance || !id)
 283     return false;
 284
 285   if (Interface_Base::UpdateSettingInActiveDialog(instance->m_addon.get(), instance->m_instanceId,
 286                                                   id, value ? "true" : "false"))
 287     return true;
 288
 289   if (!instance->m_addon->UpdateSettingBool(id, value, instance->m_instanceId))
 290   {
 291     CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - invalid setting type", __func__);
 292     return false;
 293   }
 294
 295   instance->m_addon->SaveSettings(instance->m_instanceId);
 296
 297   return true;
 298 }
 299
 300 bool IAddonInstanceHandler::set_instance_setting_int(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl,
 301                                                      const char* id,
 302                                                      int value)
 303 {
 304   IAddonInstanceHandler* instance = static_cast<IAddonInstanceHandler*>(hdl);
 305   if (!instance || !id)
 306   {
 307     CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - invalid data (instance='{}', id='{}')",
 308               __func__, hdl, static_cast<const void*>(id));
 309
 310     return false;
 311   }
 312
 313   if (Interface_Base::UpdateSettingInActiveDialog(instance->m_addon.get(), instance->m_instanceId,
 314                                                   id, std::to_string(value)))
 315     return true;
 316
 317   if (!instance->m_addon->UpdateSettingInt(id, value, instance->m_instanceId))
 318   {
 319     CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - invalid setting type", __func__);
 320     return false;
 321   }
 322
 323   instance->m_addon->SaveSettings(instance->m_instanceId);
 324
 325   return true;
 326 }
 327
 328 bool IAddonInstanceHandler::set_instance_setting_float(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl,
 329                                                        const char* id,
 330                                                        float value)
 331 {
 332   IAddonInstanceHandler* instance = static_cast<IAddonInstanceHandler*>(hdl);
 333   if (!instance || !id)
 334   {
 335     CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - invalid data (instance='{}', id='{}')",
 336               __func__, hdl, static_cast<const void*>(id));
 337
 338     return false;
 339   }
 340
 341   if (Interface_Base::UpdateSettingInActiveDialog(instance->m_addon.get(), instance->m_instanceId,
 342                                                   id, StringUtils::Format("{:f}", value)))
 343     return true;
 344
 345   if (!instance->m_addon->UpdateSettingNumber(id, static_cast<double>(value),
 346                                               instance->m_instanceId))
 347   {
 348     CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - invalid setting type", __func__);
 349     return false;
 350   }
 351
 352   instance->m_addon->SaveSettings(instance->m_instanceId);
 353
 354   return true;
 355 }
 356
 357 bool IAddonInstanceHandler::set_instance_setting_string(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl,
 358                                                         const char* id,
 359                                                         const char* value)
 360 {
 361   IAddonInstanceHandler* instance = static_cast<IAddonInstanceHandler*>(hdl);
 362   if (!instance || !id || !value)
 363   {
 364     CLog::Log(LOGERROR,
 365               "IAddonInstanceHandler::{} - invalid data (instance='{}', id='{}', value='{}')",
 366               __func__, hdl, static_cast<const void*>(id), static_cast<const void*>(value));
 367
 368     return false;
 369   }
 370
 371   if (Interface_Base::UpdateSettingInActiveDialog(instance->m_addon.get(), instance->m_instanceId,
 372                                                   id, value))
 373     return true;
 374
 375   if (!instance->m_addon->UpdateSettingString(id, value, instance->m_instanceId))
 376   {
 377     CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - invalid setting type", __func__);
 378     return false;
 379   }
 380
 381   instance->m_addon->SaveSettings(instance->m_instanceId);
 382
 383   return true;
 384 }
 385
 386 } /* namespace ADDON */