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 <cstdlib>
#include <cstring>
#include <ctime>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "tools/StringUtils.h"
 
namespace kodi
{
 
namespace gui
{
struct IRenderHelper;
} /* namespace gui */
 
//==============================================================================
using HardwareContext = ADDON_HARDWARE_CONTEXT;
//------------------------------------------------------------------------------
 
//==============================================================================
class ATTRIBUTE_HIDDEN CSettingValue
{
public:
  explicit CSettingValue(const void* settingValue) : m_settingValue(settingValue) {}
 
  bool empty() const { return (m_settingValue == nullptr) ? true : false; }
 
 
 
  std::string GetString() const { return (const char*)m_settingValue; }
 
  int GetInt() const { return *(const int*)m_settingValue; }
 
  unsigned int GetUInt() const { return *(const unsigned int*)m_settingValue; }
 
  bool GetBoolean() const { return *(const bool*)m_settingValue; }
 
  float GetFloat() const { return *(const float*)m_settingValue; }
 
  template<typename enumType>
  enumType GetEnum() const
  {
    return static_cast<enumType>(*(const int*)m_settingValue);
  }
 
 
private:
  const void* m_settingValue;
};
//------------------------------------------------------------------------------
 
namespace addon
{
 
//==============================================================================
/*
 * Internal class to control various instance types with general parts defined
 * here.
 *
 * Mainly is this currently used to identify requested instance types.
 *
 * @note This class is not need to know during add-on development thats why
 * commented with "*".
 */
class ATTRIBUTE_HIDDEN IAddonInstance
{
public:
  explicit IAddonInstance(ADDON_TYPE type, const std::string& version)
    : m_type(type), m_kodiVersion(version)
  {
  }
  virtual ~IAddonInstance() = default;
 
  virtual ADDON_STATUS CreateInstance(int instanceType,
                                      const std::string& instanceID,
                                      KODI_HANDLE instance,
                                      const std::string& version,
                                      KODI_HANDLE& addonInstance)
  {
    return ADDON_STATUS_NOT_IMPLEMENTED;
  }
 
  const ADDON_TYPE m_type;
  const std::string m_kodiVersion;
  std::string m_id;
};
 
/*
 * 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 CPP_CLASS& cppClass)
    : m_cStructure(new C_STRUCT(*cppClass.m_cStructure)), m_owner(true)
  {
  }
 
  CStructHdl(const C_STRUCT* cStructure) : m_cStructure(new C_STRUCT(*cStructure)), m_owner(true) {}
 
  CStructHdl(C_STRUCT* cStructure) : m_cStructure(cStructure) { assert(cStructure); }
 
  const CStructHdl& operator=(const CStructHdl& right)
  {
    assert(&right.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);
    }
    return *this;
  }
 
  const CStructHdl& operator=(const C_STRUCT& right)
  {
    assert(&right);
    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; }
 
protected:
  C_STRUCT* m_cStructure = nullptr;
 
private:
  bool m_owner = false;
};
 
//============================================================================
class ATTRIBUTE_HIDDEN CAddonBase
{
public:
  //============================================================================
  CAddonBase()
  {
    m_interface->toAddon->destroy = ADDONBASE_Destroy;
    m_interface->toAddon->create_instance = ADDONBASE_CreateInstance;
    m_interface->toAddon->destroy_instance = ADDONBASE_DestroyInstance;
    m_interface->toAddon->set_setting = ADDONBASE_SetSetting;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual ~CAddonBase() = default;
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual ADDON_STATUS Create() { return ADDON_STATUS_OK; }
  //----------------------------------------------------------------------------
 
  // obsolete
  virtual ADDON_STATUS GetStatus() { return ADDON_STATUS_OK; }
 
  //============================================================================
  virtual ADDON_STATUS SetSetting(const std::string& settingName,
                                  const kodi::CSettingValue& settingValue)
  {
    return ADDON_STATUS_UNKNOWN;
  }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  virtual ADDON_STATUS CreateInstance(int instanceType,
                                      const std::string& instanceID,
                                      KODI_HANDLE instance,
                                      const std::string& version,
                                      KODI_HANDLE& addonInstance)
  {
    return ADDON_STATUS_NOT_IMPLEMENTED;
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual void DestroyInstance(int instanceType,
                               const std::string& instanceID,
                               KODI_HANDLE addonInstance)
  {
  }
  //--------------------------------------------------------------------------
 
  /* Background helper for GUI render systems, e.g. Screensaver or Visualization */
  std::shared_ptr<kodi::gui::IRenderHelper> m_renderHelper;
 
  /* Global variables of class */
  static AddonGlobalInterface*
      m_interface; // Interface function table to hold addresses on add-on and from kodi
 
private:
  static inline void ADDONBASE_Destroy()
  {
    delete static_cast<CAddonBase*>(m_interface->addonBase);
    m_interface->addonBase = nullptr;
  }
 
  static inline ADDON_STATUS ADDONBASE_SetSetting(const char* settingName, const void* settingValue)
  {
    return static_cast<CAddonBase*>(m_interface->addonBase)
        ->SetSetting(settingName, CSettingValue(settingValue));
  }
 
  static inline ADDON_STATUS ADDONBASE_CreateInstance(int instanceType,
                                                      const char* instanceID,
                                                      KODI_HANDLE instance,
                                                      const char* version,
                                                      KODI_HANDLE* addonInstance,
                                                      KODI_HANDLE parent)
  {
    CAddonBase* base = static_cast<CAddonBase*>(m_interface->addonBase);
 
    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 (m_interface->firstKodiInstance == instance && m_interface->globalSingleInstance &&
        static_cast<IAddonInstance*>(m_interface->globalSingleInstance)->m_type == instanceType)
    {
      /* 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.
       */
      *addonInstance = m_interface->globalSingleInstance;
      status = ADDON_STATUS_OK;
    }
    else
    {
      /* Here it should use the CreateInstance instance function to allow
       * creation of several on one addon.
       */
 
      /* Check first a parent is defined about (e.g. Codec within inputstream) */
      if (parent != nullptr)
        status = static_cast<IAddonInstance*>(parent)->CreateInstance(
            instanceType, instanceID, instance, version, *addonInstance);
 
      /* if no parent call the main instance creation function to get it */
      if (status == ADDON_STATUS_NOT_IMPLEMENTED)
      {
        status = base->CreateInstance(instanceType, instanceID, instance, version, *addonInstance);
      }
    }
 
    if (*addonInstance == nullptr)
    {
      if (status == ADDON_STATUS_OK)
      {
        m_interface->toKodi->addon_log_msg(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*>(*addonInstance)->m_type != instanceType)
    {
      m_interface->toKodi->addon_log_msg(
          m_interface->toKodi->kodiBase, ADDON_LOG_FATAL,
          "kodi::addon::CAddonBase CreateInstance difference between given and returned");
      delete static_cast<IAddonInstance*>(*addonInstance);
      *addonInstance = nullptr;
      return ADDON_STATUS_PERMANENT_FAILURE;
    }
 
    // Store the used ID inside instance, to have on destroy calls by addon to identify
    static_cast<IAddonInstance*>(*addonInstance)->m_id = instanceID;
 
    return status;
  }
 
  static inline void ADDONBASE_DestroyInstance(int instanceType, KODI_HANDLE instance)
  {
    CAddonBase* base = static_cast<CAddonBase*>(m_interface->addonBase);
 
    if (m_interface->globalSingleInstance == nullptr && instance != base)
    {
      base->DestroyInstance(instanceType, static_cast<IAddonInstance*>(instance)->m_id, instance);
      delete static_cast<IAddonInstance*>(instance);
    }
  }
};
 
} /* namespace addon */
 
//==============================================================================
inline std::string ATTRIBUTE_HIDDEN GetKodiTypeVersion(int type)
{
  using namespace kodi::addon;
 
  char* str = CAddonBase::m_interface->toKodi->get_type_version(
      CAddonBase::m_interface->toKodi->kodiBase, type);
  std::string ret = str;
  CAddonBase::m_interface->toKodi->free_string(CAddonBase::m_interface->toKodi->kodiBase, str);
  return ret;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTRIBUTE_HIDDEN GetAddonPath(const std::string& append = "")
{
  using namespace kodi::addon;
 
  char* str =
      CAddonBase::m_interface->toKodi->get_addon_path(CAddonBase::m_interface->toKodi->kodiBase);
  std::string ret = str;
  CAddonBase::m_interface->toKodi->free_string(CAddonBase::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 ATTRIBUTE_HIDDEN GetBaseUserPath(const std::string& append = "")
{
  using namespace kodi::addon;
 
  char* str = CAddonBase::m_interface->toKodi->get_base_user_path(
      CAddonBase::m_interface->toKodi->kodiBase);
  std::string ret = str;
  CAddonBase::m_interface->toKodi->free_string(CAddonBase::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 ATTRIBUTE_HIDDEN GetLibPath()
{
  using namespace kodi::addon;
 
  return CAddonBase::m_interface->libBasePath;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTRIBUTE_HIDDEN Log(const AddonLog 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);
  CAddonBase::m_interface->toKodi->addon_log_msg(CAddonBase::m_interface->toKodi->kodiBase,
                                                 loglevel, str.c_str());
}
//------------------------------------------------------------------------------
 
//##############################################################################
 
//==============================================================================
inline bool ATTRIBUTE_HIDDEN IsSettingUsingDefault(const std::string& settingName)
{
  using namespace kodi::addon;
  return CAddonBase::m_interface->toKodi->is_setting_using_default(
      CAddonBase::m_interface->toKodi->kodiBase, settingName.c_str());
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTRIBUTE_HIDDEN CheckSettingString(const std::string& settingName,
                                                std::string& settingValue)
{
  using namespace kodi::addon;
 
  char* buffer = nullptr;
  bool ret = CAddonBase::m_interface->toKodi->get_setting_string(
      CAddonBase::m_interface->toKodi->kodiBase, settingName.c_str(), &buffer);
  if (buffer)
  {
    if (ret)
      settingValue = buffer;
    CAddonBase::m_interface->toKodi->free_string(CAddonBase::m_interface->toKodi->kodiBase, buffer);
  }
  return ret;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTRIBUTE_HIDDEN GetSettingString(const std::string& settingName,
                                                     const std::string& defaultValue = "")
{
  std::string settingValue = defaultValue;
  CheckSettingString(settingName, settingValue);
  return settingValue;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTRIBUTE_HIDDEN SetSettingString(const std::string& settingName,
                                              const std::string& settingValue)
{
  using namespace kodi::addon;
 
  CAddonBase::m_interface->toKodi->set_setting_string(CAddonBase::m_interface->toKodi->kodiBase,
                                                      settingName.c_str(), settingValue.c_str());
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTRIBUTE_HIDDEN CheckSettingInt(const std::string& settingName, int& settingValue)
{
  using namespace kodi::addon;
 
  return CAddonBase::m_interface->toKodi->get_setting_int(CAddonBase::m_interface->toKodi->kodiBase,
                                                          settingName.c_str(), &settingValue);
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline int ATTRIBUTE_HIDDEN GetSettingInt(const std::string& settingName, int defaultValue = 0)
{
  int settingValue = defaultValue;
  CheckSettingInt(settingName, settingValue);
  return settingValue;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTRIBUTE_HIDDEN SetSettingInt(const std::string& settingName, int settingValue)
{
  using namespace kodi::addon;
 
  CAddonBase::m_interface->toKodi->set_setting_int(CAddonBase::m_interface->toKodi->kodiBase,
                                                   settingName.c_str(), settingValue);
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTRIBUTE_HIDDEN CheckSettingBoolean(const std::string& settingName, bool& settingValue)
{
  using namespace kodi::addon;
 
  return CAddonBase::m_interface->toKodi->get_setting_bool(
      CAddonBase::m_interface->toKodi->kodiBase, settingName.c_str(), &settingValue);
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTRIBUTE_HIDDEN GetSettingBoolean(const std::string& settingName,
                                               bool defaultValue = false)
{
  bool settingValue = defaultValue;
  CheckSettingBoolean(settingName, settingValue);
  return settingValue;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTRIBUTE_HIDDEN SetSettingBoolean(const std::string& settingName, bool settingValue)
{
  using namespace kodi::addon;
 
  CAddonBase::m_interface->toKodi->set_setting_bool(CAddonBase::m_interface->toKodi->kodiBase,
                                                    settingName.c_str(), settingValue);
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTRIBUTE_HIDDEN CheckSettingFloat(const std::string& settingName, float& settingValue)
{
  using namespace kodi::addon;
 
  return CAddonBase::m_interface->toKodi->get_setting_float(
      CAddonBase::m_interface->toKodi->kodiBase, settingName.c_str(), &settingValue);
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline float ATTRIBUTE_HIDDEN GetSettingFloat(const std::string& settingName,
                                              float defaultValue = 0.0f)
{
  float settingValue = defaultValue;
  CheckSettingFloat(settingName, settingValue);
  return settingValue;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTRIBUTE_HIDDEN SetSettingFloat(const std::string& settingName, float settingValue)
{
  using namespace kodi::addon;
 
  CAddonBase::m_interface->toKodi->set_setting_float(CAddonBase::m_interface->toKodi->kodiBase,
                                                     settingName.c_str(), settingValue);
}
//------------------------------------------------------------------------------
 
//==============================================================================
template<typename enumType>
inline bool ATTRIBUTE_HIDDEN CheckSettingEnum(const std::string& settingName,
                                              enumType& settingValue)
{
  using namespace kodi::addon;
 
  int settingValueInt = static_cast<int>(settingValue);
  bool ret = CAddonBase::m_interface->toKodi->get_setting_int(
      CAddonBase::m_interface->toKodi->kodiBase, settingName.c_str(), &settingValueInt);
  if (ret)
    settingValue = static_cast<enumType>(settingValueInt);
  return ret;
}
//------------------------------------------------------------------------------
 
//==============================================================================
template<typename enumType>
inline enumType ATTRIBUTE_HIDDEN GetSettingEnum(const std::string& settingName,
                                                enumType defaultValue = static_cast<enumType>(0))
{
  enumType settingValue = defaultValue;
  CheckSettingEnum(settingName, settingValue);
  return settingValue;
}
//------------------------------------------------------------------------------
 
//==============================================================================
template<typename enumType>
inline void ATTRIBUTE_HIDDEN SetSettingEnum(const std::string& settingName, enumType settingValue)
{
  using namespace kodi::addon;
 
  CAddonBase::m_interface->toKodi->set_setting_int(CAddonBase::m_interface->toKodi->kodiBase,
                                                   settingName.c_str(),
                                                   static_cast<int>(settingValue));
}
//------------------------------------------------------------------------------
 
//============================================================================
inline std::string ATTRIBUTE_HIDDEN 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 void* GetInterface(const std::string& name, const std::string& version)
{
  using namespace kodi::addon;
 
  AddonToKodiFuncTable_Addon* toKodi = CAddonBase::m_interface->toKodi;
 
  return toKodi->get_interface(toKodi->kodiBase, name.c_str(), version.c_str());
}
//----------------------------------------------------------------------------
 
} /* namespace kodi */
 
//==============================================================================
#define ADDONCREATOR(AddonClass) \
  extern "C" ATTRIBUTE_DLL_EXPORT ADDON_STATUS ADDON_Create( \
      KODI_HANDLE addonInterface, const char* /*globalApiVersion*/, void* /*unused*/) \
  { \
    kodi::addon::CAddonBase::m_interface = static_cast<AddonGlobalInterface*>(addonInterface); \
    kodi::addon::CAddonBase::m_interface->addonBase = new AddonClass; \
    return static_cast<kodi::addon::CAddonBase*>(kodi::addon::CAddonBase::m_interface->addonBase) \
        ->Create(); \
  } \
  extern "C" ATTRIBUTE_DLL_EXPORT const char* ADDON_GetTypeVersion(int type) \
  { \
    return kodi::addon::GetTypeVersion(type); \
  } \
  extern "C" ATTRIBUTE_DLL_EXPORT const char* ADDON_GetTypeMinVersion(int type) \
  { \
    return kodi::addon::GetTypeMinVersion(type); \
  } \
  AddonGlobalInterface* kodi::addon::CAddonBase::m_interface = nullptr;
//------------------------------------------------------------------------------
 
#endif /* __cplusplus */