AddonBase.h

/*
 *  Copyright (C) 2005-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */
 
#pragma once
 
#include "c-api/addon_base.h"
#include "versions.h"
 
#include <assert.h> /* assert */
#include <stdarg.h> /* va_list, va_start, va_arg, va_end */
 
#ifdef __cplusplus
 
#include "tools/StringUtils.h"
 
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
 
namespace kodi
{
 
namespace gui
{
struct IRenderHelper;
} /* namespace gui */
 
//==============================================================================
using HardwareContext = ADDON_HARDWARE_CONTEXT;
//------------------------------------------------------------------------------
 
namespace addon
{

struct ATTR_DLL_LOCAL CPrivateBase
{
  // Interface function table to hold addresses on add-on and from kodi
  static AddonGlobalInterface* m_interface;
};
struct ATTR_DLL_LOCAL CPrivateBase {…};

inline char* AllocAndCopyString(const char* source)
{
  if (source)
  {
    const size_t len{strlen(source) + 1};
    char* target = new char[len];
    memcpy(target, source, len);
    return target;
  }
  return nullptr;
}

inline void FreeString(const char* str)
{
  delete[] str;
}

inline void ReallocAndCopyString(const char** stringToRealloc, const char* stringToCopy)
{
  FreeString(*stringToRealloc);
  *stringToRealloc = AllocAndCopyString(stringToCopy);
}

template<typename CPP_CLASS, typename C_STRUCT>
inline static C_STRUCT** AllocAndCopyPointerArray(std::vector<CPP_CLASS>& sourceVector,
                                                  unsigned int& targetArraySize)
{
  targetArraySize = static_cast<unsigned int>(sourceVector.size());
  if (targetArraySize > 0)
  {
    C_STRUCT** targetArray = new C_STRUCT* [targetArraySize] {};
 
    unsigned int i{0};
    for (auto& entry : sourceVector)
    {
      // Assign data to target array. Take pointer ownership.
      C_STRUCT** arrayElem{&targetArray[i]};
      *arrayElem = entry.release();
      ++i;
    }
    return targetArray;
  }
  return nullptr;
}

template<typename CPP_CLASS, typename C_STRUCT>
inline static void FreeDynamicPointerArray(C_STRUCT** targetArray, unsigned int targetArraySize)
{
  for (unsigned int i = 0; i < targetArraySize; ++i)
  {
    C_STRUCT** arrayElem{&targetArray[i]};
    CPP_CLASS::FreeResources(*arrayElem);
    delete *arrayElem;
  }
  delete[] targetArray;
}

template<typename CPP_CLASS, typename C_STRUCT>
inline static void FreeStaticPointerArray(C_STRUCT** targetArray, unsigned int targetArraySize)
{
  for (unsigned int i = 0; i < targetArraySize; ++i)
  {
    C_STRUCT** arrayElem{&targetArray[i]};
    delete *arrayElem;
  }
  delete[] targetArray;
}
 
/*
 * Internally used helper class to manage processing of a "C" structure in "CPP"
 * class.
 *
 * At constant, the "C" structure is copied, otherwise the given pointer is
 * superseded and is changeable.
 *
 * -----------------------------------------------------------------------------
 *
 * Example:
 *
 * ~~~~~~~~~~~~~{.cpp}
 * extern "C" typedef struct C_SAMPLE_DATA
 * {
 *   unsigned int iUniqueId;
 * } C_SAMPLE_DATA;
 *
 * class CPPSampleData : public CStructHdl<CPPSampleData, C_SAMPLE_DATA>
 * {
 * public:
 *   CPPSampleData() = default;
 *   CPPSampleData(const CPPSampleData& sample) : CStructHdl(sample) { }
 *   CPPSampleData(const C_SAMPLE_DATA* sample) : CStructHdl(sample) { }
 *   CPPSampleData(C_SAMPLE_DATA* sample) : CStructHdl(sample) { }
 *
 *   void SetUniqueId(unsigned int uniqueId) { m_cStructure->iUniqueId = uniqueId; }
 *   unsigned int GetUniqueId() const { return m_cStructure->iUniqueId; }
 * };
 *
 * ~~~~~~~~~~~~~
 *
 * It also works with the following example:
 *
 * ~~~~~~~~~~~~~{.cpp}
 * CPPSampleData test;
 * // Some work
 * C_SAMPLE_DATA* data = test;
 * // Give "data" to Kodi
 * ~~~~~~~~~~~~~
 */
template<class CPP_CLASS, typename C_STRUCT>
class CStructHdl
{
public:
  CStructHdl() : m_cStructure(new C_STRUCT()), m_owner(true) {}
 
  CStructHdl(const CStructHdl& cppClass)
    : m_cStructure(new C_STRUCT(*cppClass.m_cStructure)), m_owner(true)
  {
  }
 
  explicit CStructHdl(const C_STRUCT* cStructure)
    : m_cStructure(new C_STRUCT(*cStructure)), m_owner(true)
  {
  }
 
  explicit CStructHdl(C_STRUCT* cStructure) : m_cStructure(cStructure) { assert(cStructure); }
 
  const CStructHdl& operator=(const CStructHdl& right)
  {
    if (this == &right)
      return *this;
 
    if (m_cStructure && !m_owner)
    {
      memcpy(m_cStructure, right.m_cStructure, sizeof(C_STRUCT));
    }
    else
    {
      if (m_owner)
        delete m_cStructure;
      m_owner = true;
      m_cStructure = new C_STRUCT(*right.m_cStructure);
    }
    return *this;
  }
 
  const CStructHdl& operator=(const C_STRUCT& right)
  {
    assert(&right);
 
    if (m_cStructure == &right)
      return *this;
 
    if (m_cStructure && !m_owner)
    {
      memcpy(m_cStructure, &right, sizeof(C_STRUCT));
    }
    else
    {
      if (m_owner)
        delete m_cStructure;
      m_owner = true;
      m_cStructure = new C_STRUCT(*right);
    }
    return *this;
  }
 
  virtual ~CStructHdl()
  {
    if (m_owner)
      delete m_cStructure;
  }
 
  operator C_STRUCT*() { return m_cStructure; }
  operator const C_STRUCT*() const { return m_cStructure; }
 
  const C_STRUCT* GetCStructure() const { return m_cStructure; }
 
  C_STRUCT* release()
  {
    m_owner = false;
    return m_cStructure;
  }
 
protected:
  C_STRUCT* m_cStructure = nullptr;
 
private:
  bool m_owner = false;
};
class CStructHdl {…};
 
template<class CPP_CLASS, typename C_STRUCT>
class DynamicCStructHdl
{
public:
  DynamicCStructHdl() : m_cStructure(new C_STRUCT()), m_owner(true)
  {
    memset(m_cStructure, 0, sizeof(C_STRUCT));
  }
 
  DynamicCStructHdl(const DynamicCStructHdl& cppClass)
    : m_cStructure(new C_STRUCT(*cppClass.m_cStructure)), m_owner(true)
  {
    CPP_CLASS::AllocResources(cppClass.m_cStructure, m_cStructure);
  }
 
  explicit DynamicCStructHdl(const C_STRUCT* cStructure)
    : m_cStructure(new C_STRUCT(*cStructure)), m_owner(true)
  {
    CPP_CLASS::AllocResources(cStructure, m_cStructure);
  }
 
  explicit DynamicCStructHdl(C_STRUCT* cStructure) : m_cStructure(cStructure)
  {
    assert(cStructure);
  }
 
  const DynamicCStructHdl& operator=(const DynamicCStructHdl& right)
  {
    if (this == &right)
      return *this;
 
    CPP_CLASS::FreeResources(m_cStructure);
    if (m_cStructure && !m_owner)
    {
      memcpy(m_cStructure, right.m_cStructure, sizeof(C_STRUCT));
    }
    else
    {
      if (m_owner)
        delete m_cStructure;
      m_owner = true;
      m_cStructure = new C_STRUCT(*right.m_cStructure);
    }
    CPP_CLASS::AllocResources(right.m_cStructure, m_cStructure);
    return *this;
  }
 
  const DynamicCStructHdl& operator=(const C_STRUCT& right)
  {
    assert(&right);
 
    if (m_cStructure == &right)
      return *this;
 
    CPP_CLASS::FreeResources(m_cStructure);
    if (m_cStructure && !m_owner)
    {
      memcpy(m_cStructure, &right, sizeof(C_STRUCT));
    }
    else
    {
      if (m_owner)
        delete m_cStructure;
      m_owner = true;
      m_cStructure = new C_STRUCT(*right);
    }
    CPP_CLASS::AllocResources(&right, m_cStructure);
    return *this;
  }
 
  virtual ~DynamicCStructHdl()
  {
    if (m_owner)
    {
      CPP_CLASS::FreeResources(m_cStructure);
      delete m_cStructure;
    }
  }
 
  operator C_STRUCT*() { return m_cStructure; }
  operator const C_STRUCT*() const { return m_cStructure; }
 
  const C_STRUCT* GetCStructure() const { return m_cStructure; }
 
  C_STRUCT* release()
  {
    m_owner = false;
    return m_cStructure;
  }
 
protected:
  C_STRUCT* m_cStructure = nullptr;
 
private:
  bool m_owner = false;
};
class DynamicCStructHdl {…};
 
//==============================================================================
class ATTR_DLL_LOCAL CSettingValue
{
public:
  explicit CSettingValue(const std::string& settingValue) : str(settingValue) {}
 
  bool empty() const { return str.empty(); }



  const std::string& GetString() const { return str; }

  int GetInt() const { return std::atoi(str.c_str()); }

  unsigned int GetUInt() const { return std::atoi(str.c_str()); }

  bool GetBoolean() const { return std::atoi(str.c_str()) > 0; }

  float GetFloat() const { return static_cast<float>(std::atof(str.c_str())); }

  template<typename enumType>
  enumType GetEnum() const
  {
    return static_cast<enumType>(GetInt());
  }
  enumType GetEnum() const {…}

 
private:
  const std::string str;
};
class ATTR_DLL_LOCAL CSettingValue {…};

//------------------------------------------------------------------------------
 
//==============================================================================
class ATTR_DLL_LOCAL IInstanceInfo
{
public:
  explicit IInstanceInfo(KODI_ADDON_INSTANCE_STRUCT* instance) : m_instance(instance) {}



  KODI_ADDON_INSTANCE_TYPE GetType() const { return m_instance->info->type; }

  bool IsType(KODI_ADDON_INSTANCE_TYPE type) const { return m_instance->info->type == type; }

  uint32_t GetNumber() const { return m_instance->info->number; }

  std::string GetID() const { return m_instance->info->id; }

  std::string GetAPIVersion() const { return m_instance->info->version; }

  bool FirstInstance() const { return m_instance->info->first_instance; }

 
  operator KODI_ADDON_INSTANCE_STRUCT*() { return m_instance; }
 
  operator KODI_ADDON_INSTANCE_STRUCT*() const { return m_instance; }
 
private:
  IInstanceInfo() = delete;
  IInstanceInfo(const IInstanceInfo&) = delete;
 
  KODI_ADDON_INSTANCE_STRUCT* m_instance;
};
class ATTR_DLL_LOCAL IInstanceInfo {…};

//------------------------------------------------------------------------------
 
//==============================================================================
/*
 * Internal class to control various instance types with general parts defined
 * here.
 *
 * Mainly is this currently used to identify requested instance types.
 */
class ATTR_DLL_LOCAL IAddonInstance
{
public:
  explicit IAddonInstance(const kodi::addon::IInstanceInfo& instance) : m_instance(instance)
  {
    m_instance->functions->instance_setting_change_string = INSTANCE_instance_setting_change_string;
    m_instance->functions->instance_setting_change_integer =
        INSTANCE_instance_setting_change_integer;
    m_instance->functions->instance_setting_change_boolean =
        INSTANCE_instance_setting_change_boolean;
    m_instance->functions->instance_setting_change_float = INSTANCE_instance_setting_change_float;
  }
  virtual ~IAddonInstance() = default;
 
  virtual ADDON_STATUS CreateInstance(const kodi::addon::IInstanceInfo& instance,
                                      KODI_ADDON_INSTANCE_HDL& hdl)
  {
    return ADDON_STATUS_NOT_IMPLEMENTED;
  }
 
  std::string GetInstanceAPIVersion() const { return m_instance->info->version; }
 
  virtual ADDON_STATUS SetInstanceSetting(const std::string& settingName,
                                          const kodi::addon::CSettingValue& settingValue)
  {
    return ADDON_STATUS_UNKNOWN;
  }
 
  inline bool IsInstanceSettingUsingDefault(const std::string& settingName)
  {
    return m_instance->info->functions->is_instance_setting_using_default(m_instance->info->kodi,
                                                                          settingName.c_str());
  }
 
  inline std::string GetInstanceUserPath(const std::string& append = "")
  {
    using namespace kodi::addon;
 
    char* str = m_instance->info->functions->get_instance_user_path(
        CPrivateBase::m_interface->toKodi->kodiBase);
    std::string ret = str;
    CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   str);
    if (!append.empty())
    {
      if (append.at(0) != '\\' && append.at(0) != '/')
#ifdef TARGET_WINDOWS
        ret.append("\\");
#else
        ret.append("/");
#endif
      ret.append(append);
    }
    return ret;
  }
 
  inline bool CheckInstanceSettingString(const std::string& settingName, std::string& settingValue)
  {
    char* buffer = nullptr;
    bool ret = m_instance->info->functions->get_instance_setting_string(
        m_instance->info->kodi, settingName.c_str(), &buffer);
    if (buffer)
    {
      if (ret)
        settingValue = buffer;
      free(buffer);
    }
    return ret;
  }
 
  inline std::string GetInstanceSettingString(const std::string& settingName,
                                              const std::string& defaultValue = "")
  {
    std::string settingValue = defaultValue;
    CheckInstanceSettingString(settingName, settingValue);
    return settingValue;
  }
 
  inline void SetInstanceSettingString(const std::string& settingName,
                                       const std::string& settingValue)
  {
    m_instance->info->functions->set_instance_setting_string(
        m_instance->info->kodi, settingName.c_str(), settingValue.c_str());
  }
 
  inline bool CheckInstanceSettingInt(const std::string& settingName, int& settingValue)
  {
    KODI_ADDON_INSTANCE_FUNC_CB* cb = m_instance->info->functions;
    return cb->get_instance_setting_int(m_instance->info->kodi, settingName.c_str(), &settingValue);
  }
 
  inline int GetInstanceSettingInt(const std::string& settingName, int defaultValue = 0)
  {
    int settingValue = defaultValue;
    CheckInstanceSettingInt(settingName, settingValue);
    return settingValue;
  }
 
  inline void SetInstanceSettingInt(const std::string& settingName, int settingValue)
  {
    m_instance->info->functions->set_instance_setting_int(m_instance->info->kodi,
                                                          settingName.c_str(), settingValue);
  }
 
  inline bool CheckInstanceSettingBoolean(const std::string& settingName, bool& settingValue)
  {
    return m_instance->info->functions->get_instance_setting_bool(
        m_instance->info->kodi, settingName.c_str(), &settingValue);
  }
 
  inline bool GetInstanceSettingBoolean(const std::string& settingName, bool defaultValue = false)
  {
    bool settingValue = defaultValue;
    CheckInstanceSettingBoolean(settingName, settingValue);
    return settingValue;
  }
 
  inline void SetInstanceSettingBoolean(const std::string& settingName, bool settingValue)
  {
    m_instance->info->functions->set_instance_setting_bool(m_instance->info->kodi,
                                                           settingName.c_str(), settingValue);
  }
 
  inline bool CheckInstanceSettingFloat(const std::string& settingName, float& settingValue)
  {
    return m_instance->info->functions->get_instance_setting_float(
        m_instance->info->kodi, settingName.c_str(), &settingValue);
  }
 
  inline float GetInstanceSettingFloat(const std::string& settingName, float defaultValue = 0.0f)
  {
    float settingValue = defaultValue;
    CheckInstanceSettingFloat(settingName, settingValue);
    return settingValue;
  }
 
  inline void SetInstanceSettingFloat(const std::string& settingName, float settingValue)
  {
    m_instance->info->functions->set_instance_setting_float(m_instance->info->kodi,
                                                            settingName.c_str(), settingValue);
  }
 
  template<typename enumType>
  inline bool CheckInstanceSettingEnum(const std::string& settingName, enumType& settingValue)
  {
    using namespace kodi::addon;
 
    int settingValueInt = static_cast<int>(settingValue);
    bool ret = m_instance->info->functions->get_instance_setting_int(
        m_instance->info->kodi, settingName.c_str(), &settingValueInt);
    if (ret)
      settingValue = static_cast<enumType>(settingValueInt);
    return ret;
  }
 
  template<typename enumType>
  inline enumType GetInstanceSettingEnum(const std::string& settingName,
                                         enumType defaultValue = static_cast<enumType>(0))
  {
    enumType settingValue = defaultValue;
    CheckInstanceSettingEnum(settingName, settingValue);
    return settingValue;
  }
 
  template<typename enumType>
  inline void SetInstanceSettingEnum(const std::string& settingName, enumType settingValue)
  {
    m_instance->info->functions->set_instance_setting_int(
        m_instance->info->kodi, settingName.c_str(), static_cast<int>(settingValue));
  }
 
private:
  static inline ADDON_STATUS INSTANCE_instance_setting_change_string(
      const KODI_ADDON_INSTANCE_HDL hdl, const char* name, const char* value)
  {
    return static_cast<IAddonInstance*>(hdl)->SetInstanceSetting(name, CSettingValue(value));
  }
 
  static inline ADDON_STATUS INSTANCE_instance_setting_change_boolean(
      const KODI_ADDON_INSTANCE_HDL hdl, const char* name, bool value)
  {
    return static_cast<IAddonInstance*>(hdl)->SetInstanceSetting(name,
                                                                 CSettingValue(value ? "1" : "0"));
  }
 
  static inline ADDON_STATUS INSTANCE_instance_setting_change_integer(
      const KODI_ADDON_INSTANCE_HDL hdl, const char* name, int value)
  {
    return static_cast<IAddonInstance*>(hdl)->SetInstanceSetting(
        name, CSettingValue(std::to_string(value)));
  }
 
  static inline ADDON_STATUS INSTANCE_instance_setting_change_float(
      const KODI_ADDON_INSTANCE_HDL hdl, const char* name, float value)
  {
    return static_cast<IAddonInstance*>(hdl)->SetInstanceSetting(
        name, CSettingValue(std::to_string(value)));
  }
 
  friend class CAddonBase;
 
  const KODI_ADDON_INSTANCE_STRUCT* m_instance;
};
class ATTR_DLL_LOCAL IAddonInstance {…};
 
//============================================================================
class ATTR_DLL_LOCAL CAddonBase
{
public:
  //============================================================================
  CAddonBase()
  {
    CPrivateBase::m_interface->toAddon->create = nullptr;
    CPrivateBase::m_interface->toAddon->destroy = ADDONBASE_Destroy;
    CPrivateBase::m_interface->toAddon->create_instance = ADDONBASE_CreateInstance;
    CPrivateBase::m_interface->toAddon->destroy_instance = ADDONBASE_DestroyInstance;
    CPrivateBase::m_interface->toAddon->setting_change_string = ADDONBASE_setting_change_string;
    CPrivateBase::m_interface->toAddon->setting_change_boolean = ADDONBASE_setting_change_boolean;
    CPrivateBase::m_interface->toAddon->setting_change_integer = ADDONBASE_setting_change_integer;
    CPrivateBase::m_interface->toAddon->setting_change_float = ADDONBASE_setting_change_float;
  }
  CAddonBase() {…}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual ~CAddonBase() = default;
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual ADDON_STATUS Create() { return ADDON_STATUS_OK; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual ADDON_STATUS SetSetting(const std::string& settingName,
                                  const kodi::addon::CSettingValue& settingValue)
  {
    return ADDON_STATUS_UNKNOWN;
  }
  virtual ADDON_STATUS SetSetting(const std::string& settingName, {…}
  //----------------------------------------------------------------------------
 
  //==========================================================================
  virtual ADDON_STATUS CreateInstance(const kodi::addon::IInstanceInfo& instance,
                                      KODI_ADDON_INSTANCE_HDL& hdl)
  {
    return ADDON_STATUS_NOT_IMPLEMENTED;
  }
  virtual ADDON_STATUS CreateInstance(const kodi::addon::IInstanceInfo& instance, {…}
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual void DestroyInstance(const IInstanceInfo& instance, const KODI_ADDON_INSTANCE_HDL hdl) {}
  //--------------------------------------------------------------------------
 
  /* Background helper for GUI render systems, e.g. Screensaver or Visualization */
  std::shared_ptr<kodi::gui::IRenderHelper> m_renderHelper;
 
private:
  static inline void ADDONBASE_Destroy(const KODI_ADDON_HDL hdl)
  {
    delete static_cast<CAddonBase*>(hdl);
  }
 
  static inline ADDON_STATUS ADDONBASE_CreateInstance(const KODI_ADDON_HDL hdl,
                                                      struct KODI_ADDON_INSTANCE_STRUCT* instance)
  {
    CAddonBase* base = static_cast<CAddonBase*>(hdl);
 
    ADDON_STATUS status = ADDON_STATUS_NOT_IMPLEMENTED;
 
    /* Check about single instance usage:
     * 1. The kodi side instance pointer must be equal to first one
     * 2. The addon side instance pointer must be set
     * 3. And the requested type must be equal with used add-on class
     */
    if (CPrivateBase::m_interface->firstKodiInstance == instance &&
        CPrivateBase::m_interface->globalSingleInstance &&
        static_cast<IAddonInstance*>(CPrivateBase::m_interface->globalSingleInstance)
                ->m_instance->info->type == instance->info->type)
    {
      /* The handling here is intended for the case of the add-on only one
       * instance and this is integrated in the add-on base class.
       */
      instance->hdl = CPrivateBase::m_interface->globalSingleInstance;
      status = ADDON_STATUS_OK;
    }
    else
    {
      /* Here it should use the CreateInstance instance function to allow
       * creation of several on one addon.
       */
 
      IInstanceInfo instanceInfo(instance);
 
      /* Check first a parent is defined about (e.g. Codec within inputstream) */
      if (instance->info->parent != nullptr)
        status = static_cast<IAddonInstance*>(instance->info->parent)
                     ->CreateInstance(instanceInfo, instance->hdl);
 
      /* if no parent call the main instance creation function to get it */
      if (status == ADDON_STATUS_NOT_IMPLEMENTED)
      {
        status = base->CreateInstance(instanceInfo, instance->hdl);
      }
    }
 
    if (instance->hdl == nullptr)
    {
      if (status == ADDON_STATUS_OK)
      {
        CPrivateBase::m_interface->toKodi->addon_log_msg(
            CPrivateBase::m_interface->toKodi->kodiBase, ADDON_LOG_FATAL,
            "kodi::addon::CAddonBase CreateInstance returned an "
            "empty instance pointer, but reported OK!");
        return ADDON_STATUS_PERMANENT_FAILURE;
      }
      else
      {
        return status;
      }
    }
 
    if (static_cast<IAddonInstance*>(instance->hdl)->m_instance->info->type != instance->info->type)
    {
      CPrivateBase::m_interface->toKodi->addon_log_msg(
          CPrivateBase::m_interface->toKodi->kodiBase, ADDON_LOG_FATAL,
          "kodi::addon::CAddonBase CreateInstance difference between given and returned");
      delete static_cast<IAddonInstance*>(instance->hdl);
      instance->hdl = nullptr;
      return ADDON_STATUS_PERMANENT_FAILURE;
    }
 
    return status;
  }
 
  static inline void ADDONBASE_DestroyInstance(const KODI_ADDON_HDL hdl,
                                               struct KODI_ADDON_INSTANCE_STRUCT* instance)
  {
    CAddonBase* base = static_cast<CAddonBase*>(hdl);
 
    if (CPrivateBase::m_interface->globalSingleInstance == nullptr && instance->hdl != base)
    {
      IInstanceInfo instanceInfo(instance);
      base->DestroyInstance(instanceInfo, instance->hdl);
      delete static_cast<IAddonInstance*>(instance->hdl);
    }
  }
 
  static inline ADDON_STATUS ADDONBASE_setting_change_string(const KODI_ADDON_HDL hdl,
                                                             const char* name,
                                                             const char* value)
  {
    return static_cast<CAddonBase*>(hdl)->SetSetting(name, CSettingValue(value));
  }
 
  static inline ADDON_STATUS ADDONBASE_setting_change_boolean(const KODI_ADDON_HDL hdl,
                                                              const char* name,
                                                              bool value)
  {
    return static_cast<CAddonBase*>(hdl)->SetSetting(name, CSettingValue(value ? "1" : "0"));
  }
 
  static inline ADDON_STATUS ADDONBASE_setting_change_integer(const KODI_ADDON_HDL hdl,
                                                              const char* name,
                                                              int value)
  {
    return static_cast<CAddonBase*>(hdl)->SetSetting(name, CSettingValue(std::to_string(value)));
  }
 
  static inline ADDON_STATUS ADDONBASE_setting_change_float(const KODI_ADDON_HDL hdl,
                                                            const char* name,
                                                            float value)
  {
    return static_cast<CAddonBase*>(hdl)->SetSetting(name, CSettingValue(std::to_string(value)));
  }
};
class ATTR_DLL_LOCAL CAddonBase {…};
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetAddonPath(const std::string& append = "")
{
  using namespace kodi::addon;
 
  char* str = CPrivateBase::m_interface->toKodi->kodi_addon->get_addon_path(
      CPrivateBase::m_interface->toKodi->kodiBase);
  std::string ret = str;
  CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, str);
  if (!append.empty())
  {
    if (append.at(0) != '\\' && append.at(0) != '/')
#ifdef TARGET_WINDOWS
      ret.append("\\");
#else
      ret.append("/");
#endif
    ret.append(append);
  }
  return ret;
}
inline std::string ATTR_DLL_LOCAL GetAddonPath(const std::string& append = "") {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetLibPath(const std::string& append = "")
{
  using namespace kodi::addon;
 
  char* str = CPrivateBase::m_interface->toKodi->kodi_addon->get_lib_path(
      CPrivateBase::m_interface->toKodi->kodiBase);
  std::string ret = str;
  CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, str);
  if (!append.empty())
  {
    if (append.at(0) != '\\' && append.at(0) != '/')
#ifdef TARGET_WINDOWS
      ret.append("\\");
#else
      ret.append("/");
#endif
    ret.append(append);
  }
  return ret;
}
inline std::string ATTR_DLL_LOCAL GetLibPath(const std::string& append = "") {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetUserPath(const std::string& append = "")
{
  using namespace kodi::addon;
 
  char* str = CPrivateBase::m_interface->toKodi->kodi_addon->get_user_path(
      CPrivateBase::m_interface->toKodi->kodiBase);
  std::string ret = str;
  CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, str);
  if (!append.empty())
  {
    if (append.at(0) != '\\' && append.at(0) != '/')
#ifdef TARGET_WINDOWS
      ret.append("\\");
#else
      ret.append("/");
#endif
    ret.append(append);
  }
  return ret;
}
inline std::string ATTR_DLL_LOCAL GetUserPath(const std::string& append = "") {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetTempPath(const std::string& append = "")
{
  using namespace kodi::addon;
 
  char* str = CPrivateBase::m_interface->toKodi->kodi_addon->get_temp_path(
      CPrivateBase::m_interface->toKodi->kodiBase);
  std::string ret = str;
  CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, str);
  if (!append.empty())
  {
    if (append.at(0) != '\\' && append.at(0) != '/')
#ifdef TARGET_WINDOWS
      ret.append("\\");
#else
      ret.append("/");
#endif
    ret.append(append);
  }
  return ret;
}
inline std::string ATTR_DLL_LOCAL GetTempPath(const std::string& append = "") {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetLocalizedString(uint32_t labelId,
                                                     const std::string& defaultStr = "")
{
  using namespace kodi::addon;
 
  std::string retString = defaultStr;
  char* strMsg = CPrivateBase::m_interface->toKodi->kodi_addon->get_localized_string(
      CPrivateBase::m_interface->toKodi->kodiBase, labelId);
  if (strMsg != nullptr)
  {
    if (std::strlen(strMsg))
      retString = strMsg;
    CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   strMsg);
  }
  return retString;
}
inline std::string ATTR_DLL_LOCAL GetLocalizedString(uint32_t labelId, {…}
//------------------------------------------------------------------------------
 
//##############################################################################

 
//==============================================================================
inline bool ATTR_DLL_LOCAL OpenSettings()
{
  using namespace kodi::addon;
  return CPrivateBase::m_interface->toKodi->kodi_addon->open_settings_dialog(
      CPrivateBase::m_interface->toKodi->kodiBase);
}
inline bool ATTR_DLL_LOCAL OpenSettings() {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL IsSettingUsingDefault(const std::string& settingName)
{
  using namespace kodi::addon;
  return CPrivateBase::m_interface->toKodi->kodi_addon->is_setting_using_default(
      CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str());
}
inline bool ATTR_DLL_LOCAL IsSettingUsingDefault(const std::string& settingName) {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL CheckSettingString(const std::string& settingName,
                                              std::string& settingValue)
{
  using namespace kodi::addon;
 
  char* buffer = nullptr;
  bool ret = CPrivateBase::m_interface->toKodi->kodi_addon->get_setting_string(
      CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), &buffer);
  if (buffer)
  {
    if (ret)
      settingValue = buffer;
    CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   buffer);
  }
  return ret;
}
inline bool ATTR_DLL_LOCAL CheckSettingString(const std::string& settingName, {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetSettingString(const std::string& settingName,
                                                   const std::string& defaultValue = "")
{
  std::string settingValue = defaultValue;
  CheckSettingString(settingName, settingValue);
  return settingValue;
}
inline std::string ATTR_DLL_LOCAL GetSettingString(const std::string& settingName, {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTR_DLL_LOCAL SetSettingString(const std::string& settingName,
                                            const std::string& settingValue)
{
  using namespace kodi::addon;
 
  CPrivateBase::m_interface->toKodi->kodi_addon->set_setting_string(
      CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), settingValue.c_str());
}
inline void ATTR_DLL_LOCAL SetSettingString(const std::string& settingName, {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL CheckSettingInt(const std::string& settingName, int& settingValue)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_addon->get_setting_int(
      CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), &settingValue);
}
inline bool ATTR_DLL_LOCAL CheckSettingInt(const std::string& settingName, int& settingValue) {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline int ATTR_DLL_LOCAL GetSettingInt(const std::string& settingName, int defaultValue = 0)
{
  int settingValue = defaultValue;
  CheckSettingInt(settingName, settingValue);
  return settingValue;
}
inline int ATTR_DLL_LOCAL GetSettingInt(const std::string& settingName, int defaultValue = 0) {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTR_DLL_LOCAL SetSettingInt(const std::string& settingName, int settingValue)
{
  using namespace kodi::addon;
 
  CPrivateBase::m_interface->toKodi->kodi_addon->set_setting_int(
      CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), settingValue);
}
inline void ATTR_DLL_LOCAL SetSettingInt(const std::string& settingName, int settingValue) {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL CheckSettingBoolean(const std::string& settingName, bool& settingValue)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_addon->get_setting_bool(
      CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), &settingValue);
}
inline bool ATTR_DLL_LOCAL CheckSettingBoolean(const std::string& settingName, bool& settingValue) {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL GetSettingBoolean(const std::string& settingName,
                                             bool defaultValue = false)
{
  bool settingValue = defaultValue;
  CheckSettingBoolean(settingName, settingValue);
  return settingValue;
}
inline bool ATTR_DLL_LOCAL GetSettingBoolean(const std::string& settingName, {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTR_DLL_LOCAL SetSettingBoolean(const std::string& settingName, bool settingValue)
{
  using namespace kodi::addon;
 
  CPrivateBase::m_interface->toKodi->kodi_addon->set_setting_bool(
      CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), settingValue);
}
inline void ATTR_DLL_LOCAL SetSettingBoolean(const std::string& settingName, bool settingValue) {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL CheckSettingFloat(const std::string& settingName, float& settingValue)
{
  using namespace kodi::addon;
 
  return CPrivateBase::m_interface->toKodi->kodi_addon->get_setting_float(
      CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), &settingValue);
}
inline bool ATTR_DLL_LOCAL CheckSettingFloat(const std::string& settingName, float& settingValue) {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline float ATTR_DLL_LOCAL GetSettingFloat(const std::string& settingName,
                                            float defaultValue = 0.0f)
{
  float settingValue = defaultValue;
  CheckSettingFloat(settingName, settingValue);
  return settingValue;
}
inline float ATTR_DLL_LOCAL GetSettingFloat(const std::string& settingName, {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTR_DLL_LOCAL SetSettingFloat(const std::string& settingName, float settingValue)
{
  using namespace kodi::addon;
 
  CPrivateBase::m_interface->toKodi->kodi_addon->set_setting_float(
      CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), settingValue);
}
inline void ATTR_DLL_LOCAL SetSettingFloat(const std::string& settingName, float settingValue) {…}
//------------------------------------------------------------------------------
 
//==============================================================================
template<typename enumType>
inline bool ATTR_DLL_LOCAL CheckSettingEnum(const std::string& settingName, enumType& settingValue)
{
  using namespace kodi::addon;
 
  int settingValueInt = static_cast<int>(settingValue);
  bool ret = CPrivateBase::m_interface->toKodi->kodi_addon->get_setting_int(
      CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), &settingValueInt);
  if (ret)
    settingValue = static_cast<enumType>(settingValueInt);
  return ret;
}
inline bool ATTR_DLL_LOCAL CheckSettingEnum(const std::string& settingName, enumType& settingValue) {…}
//------------------------------------------------------------------------------
 
//==============================================================================
template<typename enumType>
inline enumType ATTR_DLL_LOCAL GetSettingEnum(const std::string& settingName,
                                              enumType defaultValue = static_cast<enumType>(0))
{
  enumType settingValue = defaultValue;
  CheckSettingEnum(settingName, settingValue);
  return settingValue;
}
inline enumType ATTR_DLL_LOCAL GetSettingEnum(const std::string& settingName, {…}
//------------------------------------------------------------------------------
 
//==============================================================================
template<typename enumType>
inline void ATTR_DLL_LOCAL SetSettingEnum(const std::string& settingName, enumType settingValue)
{
  using namespace kodi::addon;
 
  CPrivateBase::m_interface->toKodi->kodi_addon->set_setting_int(
      CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(),
      static_cast<int>(settingValue));
}
inline void ATTR_DLL_LOCAL SetSettingEnum(const std::string& settingName, enumType settingValue) {…}
//------------------------------------------------------------------------------

 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetAddonInfo(const std::string& id)
{
  using namespace kodi::addon;
 
  AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi;
 
  std::string strReturn;
  char* strMsg = toKodi->kodi_addon->get_addon_info(toKodi->kodiBase, id.c_str());
  if (strMsg != nullptr)
  {
    if (std::strlen(strMsg))
      strReturn = strMsg;
    toKodi->free_string(toKodi->kodiBase, strMsg);
  }
  return strReturn;
}
inline std::string ATTR_DLL_LOCAL GetAddonInfo(const std::string& id) {…}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void* GetInterface(const std::string& name, const std::string& version)
{
  using namespace kodi::addon;
 
  AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi;
 
  return toKodi->kodi_addon->get_interface(toKodi->kodiBase, name.c_str(), version.c_str());
}
inline void* GetInterface(const std::string& name, const std::string& version) {…}
//----------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetKodiTypeVersion(int type)
{
  using namespace kodi::addon;
 
  char* str = CPrivateBase::m_interface->toKodi->kodi_addon->get_type_version(
      CPrivateBase::m_interface->toKodi->kodiBase, type);
  std::string ret = str;
  CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, str);
  return ret;
}
inline std::string ATTR_DLL_LOCAL GetKodiTypeVersion(int type) {…}
//------------------------------------------------------------------------------
 
//============================================================================
inline std::string ATTR_DLL_LOCAL TranslateAddonStatus(ADDON_STATUS status)
{
  switch (status)
  {
    case ADDON_STATUS_OK:
      return "OK";
    case ADDON_STATUS_LOST_CONNECTION:
      return "Lost Connection";
    case ADDON_STATUS_NEED_RESTART:
      return "Need Restart";
    case ADDON_STATUS_NEED_SETTINGS:
      return "Need Settings";
    case ADDON_STATUS_UNKNOWN:
      return "Unknown error";
    case ADDON_STATUS_PERMANENT_FAILURE:
      return "Permanent failure";
    case ADDON_STATUS_NOT_IMPLEMENTED:
      return "Not implemented";
    default:
      break;
  }
  return "Unknown";
}
inline std::string ATTR_DLL_LOCAL TranslateAddonStatus(ADDON_STATUS status) {…}
//----------------------------------------------------------------------------
 
} /* namespace addon */
 
//==============================================================================
inline void ATTR_DLL_LOCAL Log(const ADDON_LOG loglevel, const char* format, ...)
{
  using namespace kodi::addon;
 
  va_list args;
  va_start(args, format);
  const std::string str = kodi::tools::StringUtils::FormatV(format, args);
  va_end(args);
  CPrivateBase::m_interface->toKodi->addon_log_msg(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   loglevel, str.c_str());
}
inline void ATTR_DLL_LOCAL Log(const ADDON_LOG loglevel, const char* format, ...) {…}
//------------------------------------------------------------------------------
 
} /* namespace kodi */
 
//==============================================================================
#define ADDONCREATOR(AddonClass) \
  extern "C" ATTR_DLL_EXPORT ADDON_STATUS ADDON_Create(KODI_HANDLE addonInterface) \
  { \
    using namespace kodi::addon; \
    CPrivateBase::m_interface = static_cast<AddonGlobalInterface*>(addonInterface); \
    CPrivateBase::m_interface->addonBase = new AddonClass; \
    return static_cast<CAddonBase*>(CPrivateBase::m_interface->addonBase)->Create(); \
  } \
  extern "C" ATTR_DLL_EXPORT const char* ADDON_GetTypeVersion(int type) \
  { \
    return kodi::addon::GetTypeVersion(type); \
  } \
  extern "C" ATTR_DLL_EXPORT const char* ADDON_GetTypeMinVersion(int type) \
  { \
    return kodi::addon::GetTypeMinVersion(type); \
  } \
  AddonGlobalInterface* kodi::addon::CPrivateBase::m_interface = nullptr;
//------------------------------------------------------------------------------
 
#endif /* __cplusplus */