Peripheral.h

/*
 *  Copyright (C) 2014-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 "peripheral/PeripheralUtils.h"
 
#ifdef __cplusplus
namespace kodi
{
namespace addon
{
 
//##############################################################################
 
//##############################################################################
 
//##############################################################################
 
//##############################################################################
 
//##############################################################################
 
//==============================================================================
class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance
{
public:
  //============================================================================
  CInstancePeripheral()
    : IAddonInstance(IInstanceInfo(CPrivateBase::m_interface->firstKodiInstance))
  {
    if (CPrivateBase::m_interface->globalSingleInstance != nullptr)
      throw std::logic_error("kodi::addon::CInstancePeripheral: Creation of more as one in single "
                             "instance way is not allowed!");
 
    SetAddonStruct(CPrivateBase::m_interface->firstKodiInstance);
    CPrivateBase::m_interface->globalSingleInstance = this;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  explicit CInstancePeripheral(const IInstanceInfo& instance) : IAddonInstance(instance)
  {
    if (CPrivateBase::m_interface->globalSingleInstance != nullptr)
      throw std::logic_error("kodi::addon::CInstancePeripheral: Creation of multiple together with "
                             "single instance way is not allowed!");
 
    SetAddonStruct(instance);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  ~CInstancePeripheral() override = default;
  //----------------------------------------------------------------------------
 
  //============================================================================
 
  //============================================================================
  virtual void GetCapabilities(kodi::addon::PeripheralCapabilities& capabilities) {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PERIPHERAL_ERROR PerformDeviceScan(
      std::vector<std::shared_ptr<kodi::addon::Peripheral>>& scan_results)
  {
    return PERIPHERAL_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PERIPHERAL_ERROR GetEvents(std::vector<kodi::addon::PeripheralEvent>& events)
  {
    return PERIPHERAL_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool SendEvent(const kodi::addon::PeripheralEvent& event) { return false; }
  //----------------------------------------------------------------------------
 
 
  //============================================================================
 
  //============================================================================
  virtual PERIPHERAL_ERROR GetJoystickInfo(unsigned int index, kodi::addon::Joystick& info)
  {
    return PERIPHERAL_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PERIPHERAL_ERROR GetAppearance(const kodi::addon::Joystick& joystick,
                                         std::string& controllerId)
  {
    return PERIPHERAL_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PERIPHERAL_ERROR SetAppearance(const kodi::addon::Joystick& joystick,
                                         const std::string& controllerId)
  {
    return PERIPHERAL_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PERIPHERAL_ERROR GetFeatures(const kodi::addon::Joystick& joystick,
                                       const std::string& controller_id,
                                       std::vector<kodi::addon::JoystickFeature>& features)
  {
    return PERIPHERAL_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PERIPHERAL_ERROR MapFeatures(const kodi::addon::Joystick& joystick,
                                       const std::string& controller_id,
                                       const std::vector<kodi::addon::JoystickFeature>& features)
  {
    return PERIPHERAL_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PERIPHERAL_ERROR GetIgnoredPrimitives(
      const kodi::addon::Joystick& joystick, std::vector<kodi::addon::DriverPrimitive>& primitives)
  {
    return PERIPHERAL_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PERIPHERAL_ERROR SetIgnoredPrimitives(
      const kodi::addon::Joystick& joystick,
      const std::vector<kodi::addon::DriverPrimitive>& primitives)
  {
    return PERIPHERAL_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void SaveButtonMap(const kodi::addon::Joystick& joystick) {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void RevertButtonMap(const kodi::addon::Joystick& joystick) {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void ResetButtonMap(const kodi::addon::Joystick& joystick,
                              const std::string& controller_id)
  {
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void PowerOffJoystick(unsigned int index) {}
  //----------------------------------------------------------------------------
 
 
  //============================================================================
 
  //============================================================================
  const std::string AddonPath() const { return m_instanceData->props->addon_path; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  const std::string UserPath() const { return m_instanceData->props->user_path; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void TriggerScan(void)
  {
    return m_instanceData->toKodi->trigger_scan(m_instanceData->toKodi->kodiInstance);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void RefreshButtonMaps(const std::string& deviceName = "", const std::string& controllerId = "")
  {
    return m_instanceData->toKodi->refresh_button_maps(m_instanceData->toKodi->kodiInstance,
                                                       deviceName.c_str(), controllerId.c_str());
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  unsigned int FeatureCount(const std::string& controllerId,
                            JOYSTICK_FEATURE_TYPE type = JOYSTICK_FEATURE_TYPE_UNKNOWN)
  {
    return m_instanceData->toKodi->feature_count(m_instanceData->toKodi->kodiInstance,
                                                 controllerId.c_str(), type);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  JOYSTICK_FEATURE_TYPE FeatureType(const std::string& controllerId, const std::string& featureName)
  {
    return m_instanceData->toKodi->feature_type(m_instanceData->toKodi->kodiInstance,
                                                controllerId.c_str(), featureName.c_str());
  }
  //----------------------------------------------------------------------------
 
 
private:
  void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance)
  {
    instance->hdl = this;
 
    instance->peripheral->toAddon->get_capabilities = ADDON_GetCapabilities;
    instance->peripheral->toAddon->perform_device_scan = ADDON_PerformDeviceScan;
    instance->peripheral->toAddon->free_scan_results = ADDON_FreeScanResults;
    instance->peripheral->toAddon->get_events = ADDON_GetEvents;
    instance->peripheral->toAddon->free_events = ADDON_FreeEvents;
    instance->peripheral->toAddon->send_event = ADDON_SendEvent;
 
    instance->peripheral->toAddon->get_joystick_info = ADDON_GetJoystickInfo;
    instance->peripheral->toAddon->free_joystick_info = ADDON_FreeJoystickInfo;
    instance->peripheral->toAddon->get_appearance = ADDON_GetAppearance;
    instance->peripheral->toAddon->set_appearance = ADDON_SetAppearance;
    instance->peripheral->toAddon->get_features = ADDON_GetFeatures;
    instance->peripheral->toAddon->free_features = ADDON_FreeFeatures;
    instance->peripheral->toAddon->map_features = ADDON_MapFeatures;
    instance->peripheral->toAddon->get_ignored_primitives = ADDON_GetIgnoredPrimitives;
    instance->peripheral->toAddon->free_primitives = ADDON_FreePrimitives;
    instance->peripheral->toAddon->set_ignored_primitives = ADDON_SetIgnoredPrimitives;
    instance->peripheral->toAddon->save_button_map = ADDON_SaveButtonMap;
    instance->peripheral->toAddon->revert_button_map = ADDON_RevertButtonMap;
    instance->peripheral->toAddon->reset_button_map = ADDON_ResetButtonMap;
    instance->peripheral->toAddon->power_off_joystick = ADDON_PowerOffJoystick;
 
    m_instanceData = instance->peripheral;
    m_instanceData->toAddon->addonInstance = this;
  }
 
  inline static void ADDON_GetCapabilities(const AddonInstance_Peripheral* addonInstance,
                                           PERIPHERAL_CAPABILITIES* capabilities)
  {
    if (!addonInstance || !capabilities)
      return;
 
    kodi::addon::PeripheralCapabilities peripheralCapabilities(capabilities);
    static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
        ->GetCapabilities(peripheralCapabilities);
  }
 
  inline static PERIPHERAL_ERROR ADDON_PerformDeviceScan(
      const AddonInstance_Peripheral* addonInstance,
      unsigned int* peripheral_count,
      PERIPHERAL_INFO** scan_results)
  {
    if (!addonInstance || !peripheral_count || !scan_results)
      return PERIPHERAL_ERROR_INVALID_PARAMETERS;
 
    std::vector<std::shared_ptr<kodi::addon::Peripheral>> peripherals;
    PERIPHERAL_ERROR err = static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
                               ->PerformDeviceScan(peripherals);
    if (err == PERIPHERAL_NO_ERROR)
    {
      *peripheral_count = static_cast<unsigned int>(peripherals.size());
      kodi::addon::Peripherals::ToStructs(peripherals, scan_results);
    }
 
    return err;
  }
 
  inline static void ADDON_FreeScanResults(const AddonInstance_Peripheral* addonInstance,
                                           unsigned int peripheral_count,
                                           PERIPHERAL_INFO* scan_results)
  {
    if (!addonInstance)
      return;
 
    kodi::addon::Peripherals::FreeStructs(peripheral_count, scan_results);
  }
 
  inline static PERIPHERAL_ERROR ADDON_GetEvents(const AddonInstance_Peripheral* addonInstance,
                                                 unsigned int* event_count,
                                                 PERIPHERAL_EVENT** events)
  {
    if (!addonInstance || !event_count || !events)
      return PERIPHERAL_ERROR_INVALID_PARAMETERS;
 
    std::vector<kodi::addon::PeripheralEvent> peripheralEvents;
    PERIPHERAL_ERROR err = static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
                               ->GetEvents(peripheralEvents);
    if (err == PERIPHERAL_NO_ERROR)
    {
      *event_count = static_cast<unsigned int>(peripheralEvents.size());
      kodi::addon::PeripheralEvents::ToStructs(peripheralEvents, events);
    }
 
    return err;
  }
 
  inline static void ADDON_FreeEvents(const AddonInstance_Peripheral* addonInstance,
                                      unsigned int event_count,
                                      PERIPHERAL_EVENT* events)
  {
    if (!addonInstance)
      return;
 
    kodi::addon::PeripheralEvents::FreeStructs(event_count, events);
  }
 
  inline static bool ADDON_SendEvent(const AddonInstance_Peripheral* addonInstance,
                                     const PERIPHERAL_EVENT* event)
  {
    if (!addonInstance || !event)
      return false;
    return static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
        ->SendEvent(kodi::addon::PeripheralEvent(*event));
  }
 
  inline static PERIPHERAL_ERROR ADDON_GetJoystickInfo(
      const AddonInstance_Peripheral* addonInstance, unsigned int index, JOYSTICK_INFO* info)
  {
    if (!addonInstance || !info)
      return PERIPHERAL_ERROR_INVALID_PARAMETERS;
 
    kodi::addon::Joystick addonInfo;
    PERIPHERAL_ERROR err = static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
                               ->GetJoystickInfo(index, addonInfo);
    if (err == PERIPHERAL_NO_ERROR)
    {
      addonInfo.ToStruct(*info);
    }
 
    return err;
  }
 
  inline static void ADDON_FreeJoystickInfo(const AddonInstance_Peripheral* addonInstance,
                                            JOYSTICK_INFO* info)
  {
    if (!addonInstance)
      return;
 
    kodi::addon::Joystick::FreeStruct(*info);
  }
 
  inline static PERIPHERAL_ERROR ADDON_GetAppearance(const AddonInstance_Peripheral* addonInstance,
                                                     const JOYSTICK_INFO* joystick,
                                                     char* buffer,
                                                     unsigned int bufferSize)
  {
    if (addonInstance == nullptr || joystick == nullptr || buffer == nullptr || bufferSize == 0)
      return PERIPHERAL_ERROR_INVALID_PARAMETERS;
 
    kodi::addon::Joystick addonJoystick(*joystick);
    std::string controllerId;
 
    PERIPHERAL_ERROR err = static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
                               ->GetAppearance(addonJoystick, controllerId);
    if (err == PERIPHERAL_NO_ERROR)
    {
      std::strncpy(buffer, controllerId.c_str(), bufferSize - 1);
      buffer[bufferSize - 1] = '\0';
    }
 
    return err;
  }
 
  inline static PERIPHERAL_ERROR ADDON_SetAppearance(const AddonInstance_Peripheral* addonInstance,
                                                     const JOYSTICK_INFO* joystick,
                                                     const char* controllerId)
  {
    if (addonInstance == nullptr || joystick == nullptr || controllerId == nullptr)
      return PERIPHERAL_ERROR_INVALID_PARAMETERS;
 
    kodi::addon::Joystick addonJoystick(*joystick);
    std::string strControllerId(controllerId);
 
    return static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
        ->SetAppearance(addonJoystick, strControllerId);
  }
 
  inline static PERIPHERAL_ERROR ADDON_GetFeatures(const AddonInstance_Peripheral* addonInstance,
                                                   const JOYSTICK_INFO* joystick,
                                                   const char* controller_id,
                                                   unsigned int* feature_count,
                                                   JOYSTICK_FEATURE** features)
  {
    if (!addonInstance || !joystick || !controller_id || !feature_count || !features)
      return PERIPHERAL_ERROR_INVALID_PARAMETERS;
 
    kodi::addon::Joystick addonJoystick(*joystick);
    std::vector<kodi::addon::JoystickFeature> featuresVector;
 
    PERIPHERAL_ERROR err = static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
                               ->GetFeatures(addonJoystick, controller_id, featuresVector);
    if (err == PERIPHERAL_NO_ERROR)
    {
      *feature_count = static_cast<unsigned int>(featuresVector.size());
      kodi::addon::JoystickFeatures::ToStructs(featuresVector, features);
    }
 
    return err;
  }
 
  inline static void ADDON_FreeFeatures(const AddonInstance_Peripheral* addonInstance,
                                        unsigned int feature_count,
                                        JOYSTICK_FEATURE* features)
  {
    if (!addonInstance)
      return;
 
    kodi::addon::JoystickFeatures::FreeStructs(feature_count, features);
  }
 
  inline static PERIPHERAL_ERROR ADDON_MapFeatures(const AddonInstance_Peripheral* addonInstance,
                                                   const JOYSTICK_INFO* joystick,
                                                   const char* controller_id,
                                                   unsigned int feature_count,
                                                   const JOYSTICK_FEATURE* features)
  {
    if (!addonInstance || !joystick || !controller_id || (feature_count > 0 && !features))
      return PERIPHERAL_ERROR_INVALID_PARAMETERS;
 
    kodi::addon::Joystick addonJoystick(*joystick);
    std::vector<kodi::addon::JoystickFeature> primitiveVector;
 
    for (unsigned int i = 0; i < feature_count; i++)
      primitiveVector.emplace_back(*(features + i));
 
    return static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
        ->MapFeatures(addonJoystick, controller_id, primitiveVector);
  }
 
  inline static PERIPHERAL_ERROR ADDON_GetIgnoredPrimitives(
      const AddonInstance_Peripheral* addonInstance,
      const JOYSTICK_INFO* joystick,
      unsigned int* primitive_count,
      JOYSTICK_DRIVER_PRIMITIVE** primitives)
  {
    if (!addonInstance || !joystick || !primitive_count || !primitives)
      return PERIPHERAL_ERROR_INVALID_PARAMETERS;
 
    kodi::addon::Joystick addonJoystick(*joystick);
    std::vector<kodi::addon::DriverPrimitive> primitiveVector;
 
    PERIPHERAL_ERROR err = static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
                               ->GetIgnoredPrimitives(addonJoystick, primitiveVector);
    if (err == PERIPHERAL_NO_ERROR)
    {
      *primitive_count = static_cast<unsigned int>(primitiveVector.size());
      kodi::addon::DriverPrimitives::ToStructs(primitiveVector, primitives);
    }
 
    return err;
  }
 
  inline static void ADDON_FreePrimitives(const AddonInstance_Peripheral* addonInstance,
                                          unsigned int primitive_count,
                                          JOYSTICK_DRIVER_PRIMITIVE* primitives)
  {
    if (!addonInstance)
      return;
 
    kodi::addon::DriverPrimitives::FreeStructs(primitive_count, primitives);
  }
 
  inline static PERIPHERAL_ERROR ADDON_SetIgnoredPrimitives(
      const AddonInstance_Peripheral* addonInstance,
      const JOYSTICK_INFO* joystick,
      unsigned int primitive_count,
      const JOYSTICK_DRIVER_PRIMITIVE* primitives)
  {
    if (!addonInstance || !joystick || (primitive_count > 0 && !primitives))
      return PERIPHERAL_ERROR_INVALID_PARAMETERS;
 
    kodi::addon::Joystick addonJoystick(*joystick);
    std::vector<kodi::addon::DriverPrimitive> primitiveVector;
 
    for (unsigned int i = 0; i < primitive_count; i++)
      primitiveVector.emplace_back(*(primitives + i));
 
    return static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
        ->SetIgnoredPrimitives(addonJoystick, primitiveVector);
  }
 
  inline static void ADDON_SaveButtonMap(const AddonInstance_Peripheral* addonInstance,
                                         const JOYSTICK_INFO* joystick)
  {
    if (!addonInstance || !joystick)
      return;
 
    kodi::addon::Joystick addonJoystick(*joystick);
    static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
        ->SaveButtonMap(addonJoystick);
  }
 
  inline static void ADDON_RevertButtonMap(const AddonInstance_Peripheral* addonInstance,
                                           const JOYSTICK_INFO* joystick)
  {
    if (!addonInstance || !joystick)
      return;
 
    kodi::addon::Joystick addonJoystick(*joystick);
    static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
        ->RevertButtonMap(addonJoystick);
  }
 
  inline static void ADDON_ResetButtonMap(const AddonInstance_Peripheral* addonInstance,
                                          const JOYSTICK_INFO* joystick,
                                          const char* controller_id)
  {
    if (!addonInstance || !joystick || !controller_id)
      return;
 
    kodi::addon::Joystick addonJoystick(*joystick);
    static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
        ->ResetButtonMap(addonJoystick, controller_id);
  }
 
  inline static void ADDON_PowerOffJoystick(const AddonInstance_Peripheral* addonInstance,
                                            unsigned int index)
  {
    if (!addonInstance)
      return;
 
    static_cast<CInstancePeripheral*>(addonInstance->toAddon->addonInstance)
        ->PowerOffJoystick(index);
  }
 
  AddonInstance_Peripheral* m_instanceData;
};
 
} /* namespace addon */
} /* namespace kodi */
#endif /* __cplusplus */