General.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 "AddonBase.h"
#include "c-api/general.h"
#include "tools/StringUtils.h"
 
#ifdef __cplusplus
 
//==============================================================================
typedef struct kodi_version_t
{
  std::string compile_name;
  int major;
  int minor;
  std::string revision;
  std::string tag;
  std::string tag_revision;
} kodi_version_t;
//------------------------------------------------------------------------------
 
namespace kodi
{
 
//==============================================================================
inline bool ATTR_DLL_LOCAL UnknownToUTF8(const std::string& stringSrc,
                                         std::string& utf8StringDst,
                                         bool failOnBadChar = false)
{
  using namespace kodi::addon;
 
  bool ret = false;
  char* retString = CPrivateBase::m_interface->toKodi->kodi->unknown_to_utf8(
      CPrivateBase::m_interface->toKodi->kodiBase, stringSrc.c_str(), &ret, failOnBadChar);
  if (retString != nullptr)
  {
    if (ret)
      utf8StringDst = retString;
    CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   retString);
  }
  return ret;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetLanguage(LangFormats format = LANG_FMT_ENGLISH_NAME,
                                              bool region = false)
{
  using namespace kodi::addon;
 
  std::string language;
  char* retString = CPrivateBase::m_interface->toKodi->kodi->get_language(
      CPrivateBase::m_interface->toKodi->kodiBase, format, region);
  if (retString != nullptr)
  {
    if (std::strlen(retString))
      language = retString;
    CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   retString);
  }
  return language;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTR_DLL_LOCAL QueueFormattedNotification(QueueMsg type, 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->kodi->queue_notification(
      CPrivateBase::m_interface->toKodi->kodiBase, type, "", str.c_str(), "", 5000, false, 1000);
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTR_DLL_LOCAL QueueNotification(QueueMsg type,
                                             const std::string& header,
                                             const std::string& message,
                                             const std::string& imageFile = "",
                                             unsigned int displayTime = 5000,
                                             bool withSound = true,
                                             unsigned int messageTime = 1000)
{
  using namespace kodi::addon;
 
  CPrivateBase::m_interface->toKodi->kodi->queue_notification(
      CPrivateBase::m_interface->toKodi->kodiBase, type, header.c_str(), message.c_str(),
      imageFile.c_str(), displayTime, withSound, messageTime);
}
//------------------------------------------------------------------------------
 
//============================================================================
inline std::string ATTR_DLL_LOCAL GetMD5(const std::string& text)
{
  using namespace kodi::addon;
 
  char* md5ret = static_cast<char*>(malloc(40 * sizeof(char))); // md5 size normally 32 bytes
  CPrivateBase::m_interface->toKodi->kodi->get_md5(CPrivateBase::m_interface->toKodi->kodiBase,
                                                   text.c_str(), md5ret);
  std::string md5 = md5ret;
  free(md5ret);
  return md5;
}
//----------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetRegion(const std::string& id)
{
  using namespace kodi::addon;
 
  AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi;
 
  std::string strReturn;
  char* strMsg = toKodi->kodi->get_region(toKodi->kodiBase, id.c_str());
  if (strMsg != nullptr)
  {
    if (std::strlen(strMsg))
      strReturn = strMsg;
    toKodi->free_string(toKodi->kodiBase, strMsg);
  }
  return strReturn;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTR_DLL_LOCAL GetFreeMem(long& free, long& total, bool asBytes = false)
{
  using namespace kodi::addon;
 
  free = -1;
  total = -1;
  AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi;
  toKodi->kodi->get_free_mem(toKodi->kodiBase, &free, &total, asBytes);
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline int ATTR_DLL_LOCAL GetGlobalIdleTime()
{
  using namespace kodi::addon;
 
  AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi;
  return toKodi->kodi->get_global_idle_time(toKodi->kodiBase);
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline std::string ATTR_DLL_LOCAL GetCurrentSkinId()
{
  using namespace kodi::addon;
 
  AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi;
 
  std::string strReturn;
  char* strMsg = toKodi->kodi->get_current_skin_id(toKodi->kodiBase);
  if (strMsg != nullptr)
  {
    if (std::strlen(strMsg))
      strReturn = strMsg;
    toKodi->free_string(toKodi->kodiBase, strMsg);
  }
  return strReturn;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL IsAddonAvailable(const std::string& id,
                                            std::string& version,
                                            bool& enabled)
{
  using namespace kodi::addon;
 
  AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi;
 
  char* cVersion = nullptr;
  bool ret = toKodi->kodi->is_addon_avilable(toKodi->kodiBase, id.c_str(), &cVersion, &enabled);
  if (cVersion)
  {
    version = cVersion;
    toKodi->free_string(toKodi->kodiBase, cVersion);
  }
  return ret;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline void ATTR_DLL_LOCAL KodiVersion(kodi_version_t& version)
{
  using namespace kodi::addon;
 
  char* compile_name = nullptr;
  char* revision = nullptr;
  char* tag = nullptr;
  char* tag_revision = nullptr;
 
  AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi;
  toKodi->kodi->kodi_version(toKodi->kodiBase, &compile_name, &version.major, &version.minor,
                             &revision, &tag, &tag_revision);
  if (compile_name != nullptr)
  {
    version.compile_name = compile_name;
    toKodi->free_string(toKodi->kodiBase, compile_name);
  }
  if (revision != nullptr)
  {
    version.revision = revision;
    toKodi->free_string(toKodi->kodiBase, revision);
  }
  if (tag != nullptr)
  {
    version.tag = tag;
    toKodi->free_string(toKodi->kodiBase, tag);
  }
  if (tag_revision != nullptr)
  {
    version.tag_revision = tag_revision;
    toKodi->free_string(toKodi->kodiBase, tag_revision);
  }
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL GetKeyboardLayout(int modifierKey,
                                             std::string& layout_name,
                                             std::vector<std::vector<std::string>>& layout)
{
  using namespace kodi::addon;
 
  AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi;
  AddonKeyboardKeyTable c_layout;
  char* c_layout_name = nullptr;
  bool ret =
      toKodi->kodi->get_keyboard_layout(toKodi->kodiBase, &c_layout_name, modifierKey, &c_layout);
  if (ret)
  {
    if (c_layout_name)
    {
      layout_name = c_layout_name;
      toKodi->free_string(toKodi->kodiBase, c_layout_name);
    }
 
    layout.resize(STD_KB_BUTTONS_MAX_ROWS);
    for (unsigned int row = 0; row < STD_KB_BUTTONS_MAX_ROWS; row++)
    {
      layout[row].resize(STD_KB_BUTTONS_PER_ROW);
      for (unsigned int column = 0; column < STD_KB_BUTTONS_PER_ROW; column++)
      {
        char* button = c_layout.keys[row][column];
        if (button)
        {
          layout[row][column] = button;
          toKodi->free_string(toKodi->kodiBase, button);
        }
      }
    }
  }
  return ret;
}
//------------------------------------------------------------------------------
 
//==============================================================================
inline bool ATTR_DLL_LOCAL ChangeKeyboardLayout(std::string& layout_name)
{
  using namespace kodi::addon;
 
  AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi;
  char* c_layout_name = nullptr;
  bool ret = toKodi->kodi->change_keyboard_layout(toKodi->kodiBase, &c_layout_name);
  if (c_layout_name)
  {
    layout_name = c_layout_name;
    toKodi->free_string(toKodi->kodiBase, c_layout_name);
  }
 
  return ret;
}
//------------------------------------------------------------------------------
 
} /* namespace kodi */
 
#endif /* __cplusplus */