1 files changed, 682 insertions, 0 deletions

diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Peripheral.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Peripheral.h
new file mode 100644
index 0000000..631b9b4
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Peripheral.h
@@ -0,0 +1,682 @@
+#pragma once
+/*
+ *      Copyright (C) 2014-2017 Team Kodi
+ *      http://kodi.tv
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this Program; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../AddonBase.h"
+
+namespace kodi { namespace addon { class CInstancePeripheral; }}
+
+/* indicates a joystick has no preference for port number */
+#define NO_PORT_REQUESTED     (-1)
+
+/* joystick's driver button/hat/axis index is unknown */
+#define DRIVER_INDEX_UNKNOWN  (-1)
+
+extern "C"
+{
+
+  /// @name Peripheral types
+  ///{
+  typedef enum PERIPHERAL_ERROR
+  {
+    PERIPHERAL_NO_ERROR                      =  0, // no error occurred
+    PERIPHERAL_ERROR_UNKNOWN                 = -1, // an unknown error occurred
+    PERIPHERAL_ERROR_FAILED                  = -2, // the command failed
+    PERIPHERAL_ERROR_INVALID_PARAMETERS      = -3, // the parameters of the method are invalid for this operation
+    PERIPHERAL_ERROR_NOT_IMPLEMENTED         = -4, // the method that the frontend called is not implemented
+    PERIPHERAL_ERROR_NOT_CONNECTED           = -5, // no peripherals are connected
+    PERIPHERAL_ERROR_CONNECTION_FAILED       = -6, // peripherals are connected, but command was interrupted
+  } PERIPHERAL_ERROR;
+
+  typedef enum PERIPHERAL_TYPE
+  {
+    PERIPHERAL_TYPE_UNKNOWN,
+    PERIPHERAL_TYPE_JOYSTICK,
+    PERIPHERAL_TYPE_KEYBOARD,
+  } PERIPHERAL_TYPE;
+
+  typedef struct PERIPHERAL_INFO
+  {
+    PERIPHERAL_TYPE type;           /*!< @brief type of peripheral */
+    char*           name;           /*!< @brief name of peripheral */
+    uint16_t        vendor_id;      /*!< @brief vendor ID of peripheral, 0x0000 if unknown */
+    uint16_t        product_id;     /*!< @brief product ID of peripheral, 0x0000 if unknown */
+    unsigned int    index;          /*!< @brief the order in which the add-on identified this peripheral */
+  } ATTRIBUTE_PACKED PERIPHERAL_INFO;
+
+  /*!
+   * @brief Peripheral add-on capabilities.
+   * If a capability is set to true, then the corresponding methods from
+   * kodi_peripheral_dll.h need to be implemented.
+   */
+  typedef struct PERIPHERAL_CAPABILITIES
+  {
+    bool provides_joysticks;            /*!< @brief true if the add-on provides joysticks */
+    bool provides_joystick_rumble;
+    bool provides_joystick_power_off;
+    bool provides_buttonmaps;           /*!< @brief true if the add-on provides button maps */
+  } ATTRIBUTE_PACKED PERIPHERAL_CAPABILITIES;
+  ///}
+
+  /// @name Event types
+  ///{
+  typedef enum PERIPHERAL_EVENT_TYPE
+  {
+    PERIPHERAL_EVENT_TYPE_NONE,           /*!< @brief unknown event */
+    PERIPHERAL_EVENT_TYPE_DRIVER_BUTTON,  /*!< @brief state changed for joystick driver button */
+    PERIPHERAL_EVENT_TYPE_DRIVER_HAT,     /*!< @brief state changed for joystick driver hat */
+    PERIPHERAL_EVENT_TYPE_DRIVER_AXIS,    /*!< @brief state changed for joystick driver axis */
+    PERIPHERAL_EVENT_TYPE_SET_MOTOR,      /*!< @brief set the state for joystick rumble motor */
+  } PERIPHERAL_EVENT_TYPE;
+
+  typedef enum JOYSTICK_STATE_BUTTON
+  {
+    JOYSTICK_STATE_BUTTON_UNPRESSED = 0x0,    /*!< @brief button is released */
+    JOYSTICK_STATE_BUTTON_PRESSED   = 0x1,    /*!< @brief button is pressed */
+  } JOYSTICK_STATE_BUTTON;
+
+  typedef enum JOYSTICK_STATE_HAT
+  {
+    JOYSTICK_STATE_HAT_UNPRESSED  = 0x0,    /*!< @brief no directions are pressed */
+    JOYSTICK_STATE_HAT_LEFT       = 0x1,    /*!< @brief only left is pressed */
+    JOYSTICK_STATE_HAT_RIGHT      = 0x2,    /*!< @brief only right is pressed */
+    JOYSTICK_STATE_HAT_UP         = 0x4,    /*!< @brief only up is pressed */
+    JOYSTICK_STATE_HAT_DOWN       = 0x8,    /*!< @brief only down is pressed */
+    JOYSTICK_STATE_HAT_LEFT_UP    = JOYSTICK_STATE_HAT_LEFT  | JOYSTICK_STATE_HAT_UP,
+    JOYSTICK_STATE_HAT_LEFT_DOWN  = JOYSTICK_STATE_HAT_LEFT  | JOYSTICK_STATE_HAT_DOWN,
+    JOYSTICK_STATE_HAT_RIGHT_UP   = JOYSTICK_STATE_HAT_RIGHT | JOYSTICK_STATE_HAT_UP,
+    JOYSTICK_STATE_HAT_RIGHT_DOWN = JOYSTICK_STATE_HAT_RIGHT | JOYSTICK_STATE_HAT_DOWN,
+  } JOYSTICK_STATE_HAT;
+
+  /*!
+   * @brief value in the closed interval [-1.0, 1.0]
+   *
+   * The axis state uses the XInput coordinate system:
+   *   - Negative values signify down or to the left
+   *   - Positive values signify up or to the right
+   */
+  typedef float JOYSTICK_STATE_AXIS;
+
+  typedef float JOYSTICK_STATE_MOTOR;
+
+  typedef struct PERIPHERAL_EVENT
+  {
+    unsigned int             peripheral_index;
+    PERIPHERAL_EVENT_TYPE    type;
+    unsigned int             driver_index;
+    JOYSTICK_STATE_BUTTON    driver_button_state;
+    JOYSTICK_STATE_HAT       driver_hat_state;
+    JOYSTICK_STATE_AXIS      driver_axis_state;
+    JOYSTICK_STATE_MOTOR     motor_state;
+  } ATTRIBUTE_PACKED PERIPHERAL_EVENT;
+  ///}
+
+  /// @name Joystick types
+  ///{
+  typedef struct JOYSTICK_INFO
+  {
+    PERIPHERAL_INFO peripheral;         /*!< @brief peripheral info for this joystick */
+    char*           provider;           /*!< @brief name of the driver or interface providing the joystick */
+    int             requested_port;     /*!< @brief requested port number (such as for 360 controllers), or NO_PORT_REQUESTED */
+    unsigned int    button_count;       /*!< @brief number of buttons reported by the driver */
+    unsigned int    hat_count;          /*!< @brief number of hats reported by the driver */
+    unsigned int    axis_count;         /*!< @brief number of axes reported by the driver */
+    unsigned int    motor_count;        /*!< @brief number of motors reported by the driver */
+    bool            supports_poweroff;  /*!< @brief whether the joystick supports being powered off */
+  } ATTRIBUTE_PACKED JOYSTICK_INFO;
+
+  typedef enum JOYSTICK_DRIVER_PRIMITIVE_TYPE
+  {
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE_UNKNOWN,
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE_BUTTON,
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE_HAT_DIRECTION,
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE_SEMIAXIS,
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE_MOTOR,
+  } JOYSTICK_DRIVER_PRIMITIVE_TYPE;
+
+  typedef struct JOYSTICK_DRIVER_BUTTON
+  {
+    int              index;
+  } ATTRIBUTE_PACKED JOYSTICK_DRIVER_BUTTON;
+
+  typedef enum JOYSTICK_DRIVER_HAT_DIRECTION
+  {
+    JOYSTICK_DRIVER_HAT_UNKNOWN,
+    JOYSTICK_DRIVER_HAT_LEFT,
+    JOYSTICK_DRIVER_HAT_RIGHT,
+    JOYSTICK_DRIVER_HAT_UP,
+    JOYSTICK_DRIVER_HAT_DOWN,
+  } JOYSTICK_DRIVER_HAT_DIRECTION;
+
+  typedef struct JOYSTICK_DRIVER_HAT
+  {
+    int                           index;
+    JOYSTICK_DRIVER_HAT_DIRECTION direction;
+  } ATTRIBUTE_PACKED JOYSTICK_DRIVER_HAT;
+
+  typedef enum JOYSTICK_DRIVER_SEMIAXIS_DIRECTION
+  {
+    JOYSTICK_DRIVER_SEMIAXIS_NEGATIVE = -1, /*!< @brief negative half of the axis */
+    JOYSTICK_DRIVER_SEMIAXIS_UNKNOWN  =  0, /*!< @brief unknown direction */
+    JOYSTICK_DRIVER_SEMIAXIS_POSITIVE =  1, /*!< @brief positive half of the axis */
+  } JOYSTICK_DRIVER_SEMIAXIS_DIRECTION;
+
+  typedef struct JOYSTICK_DRIVER_SEMIAXIS
+  {
+    int                                index;
+    int                                center;
+    JOYSTICK_DRIVER_SEMIAXIS_DIRECTION direction;
+    unsigned int                       range;
+  } ATTRIBUTE_PACKED JOYSTICK_DRIVER_SEMIAXIS;
+
+  typedef struct JOYSTICK_DRIVER_MOTOR
+  {
+    int              index;
+  } ATTRIBUTE_PACKED JOYSTICK_DRIVER_MOTOR;
+
+  typedef struct JOYSTICK_DRIVER_PRIMITIVE
+  {
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE    type;
+    union
+    {
+      struct JOYSTICK_DRIVER_BUTTON   button;
+      struct JOYSTICK_DRIVER_HAT      hat;
+      struct JOYSTICK_DRIVER_SEMIAXIS semiaxis;
+      struct JOYSTICK_DRIVER_MOTOR    motor;
+    };
+  } ATTRIBUTE_PACKED JOYSTICK_DRIVER_PRIMITIVE;
+
+  typedef enum JOYSTICK_FEATURE_TYPE
+  {
+    JOYSTICK_FEATURE_TYPE_UNKNOWN,
+    JOYSTICK_FEATURE_TYPE_SCALAR,
+    JOYSTICK_FEATURE_TYPE_ANALOG_STICK,
+    JOYSTICK_FEATURE_TYPE_ACCELEROMETER,
+    JOYSTICK_FEATURE_TYPE_MOTOR,
+  } JOYSTICK_FEATURE_TYPE;
+
+  typedef enum JOYSTICK_FEATURE_PRIMITIVE
+  {
+    // Scalar feature
+    JOYSTICK_SCALAR_PRIMITIVE = 0,
+
+    // Analog stick
+    JOYSTICK_ANALOG_STICK_UP = 0,
+    JOYSTICK_ANALOG_STICK_DOWN = 1,
+    JOYSTICK_ANALOG_STICK_RIGHT = 2,
+    JOYSTICK_ANALOG_STICK_LEFT = 3,
+
+    // Accelerometer
+    JOYSTICK_ACCELEROMETER_POSITIVE_X = 0,
+    JOYSTICK_ACCELEROMETER_POSITIVE_Y = 1,
+    JOYSTICK_ACCELEROMETER_POSITIVE_Z = 2,
+
+    // Motor
+    JOYSTICK_MOTOR_PRIMITIVE = 0,
+
+    // Maximum number of primitives
+    JOYSTICK_PRIMITIVE_MAX = 4,
+  } JOYSTICK_FEATURE_PRIMITIVE;
+
+  typedef struct JOYSTICK_FEATURE
+  {
+    char*                                   name;
+    JOYSTICK_FEATURE_TYPE                   type;
+    struct JOYSTICK_DRIVER_PRIMITIVE        primitives[JOYSTICK_PRIMITIVE_MAX];
+  } ATTRIBUTE_PACKED JOYSTICK_FEATURE;
+  ///}
+
+  typedef struct AddonProps_Peripheral
+  {
+    const char* user_path;              /*!< @brief path to the user profile */
+    const char* addon_path;             /*!< @brief path to this add-on */
+  } ATTRIBUTE_PACKED AddonProps_Peripheral;
+
+  struct AddonInstance_Peripheral;
+
+  typedef struct AddonToKodiFuncTable_Peripheral
+  {
+    KODI_HANDLE kodiInstance;
+    void (*trigger_scan)(void* kodiInstance);
+    void (*refresh_button_maps)(void* kodiInstance, const char* device_name, const char* controller_id);
+    unsigned int (*feature_count)(void* kodiInstance, const char* controller_id, JOYSTICK_FEATURE_TYPE type);
+  } AddonToKodiFuncTable_Peripheral;
+
+  //! @todo Mouse, light gun, multitouch
+
+  typedef struct KodiToAddonFuncTable_Peripheral
+  {
+    kodi::addon::CInstancePeripheral* addonInstance;
+
+    void (__cdecl* get_capabilities)(const AddonInstance_Peripheral* addonInstance, PERIPHERAL_CAPABILITIES* capabilities);
+    PERIPHERAL_ERROR (__cdecl* perform_device_scan)(const AddonInstance_Peripheral* addonInstance, unsigned int* peripheral_count, PERIPHERAL_INFO** scan_results);
+    void (__cdecl* free_scan_results)(const AddonInstance_Peripheral* addonInstance, unsigned int peripheral_count, PERIPHERAL_INFO* scan_results);
+    PERIPHERAL_ERROR (__cdecl* get_events)(const AddonInstance_Peripheral* addonInstance, unsigned int* event_count, PERIPHERAL_EVENT** events);
+    void (__cdecl* free_events)(const AddonInstance_Peripheral* addonInstance, unsigned int event_count, PERIPHERAL_EVENT* events);
+    bool (__cdecl* send_event)(const AddonInstance_Peripheral* addonInstance, const PERIPHERAL_EVENT* event);
+
+    /// @name Joystick operations
+    ///{
+    PERIPHERAL_ERROR (__cdecl* get_joystick_info)(const AddonInstance_Peripheral* addonInstance, unsigned int index, JOYSTICK_INFO* info);
+    void (__cdecl* free_joystick_info)(const AddonInstance_Peripheral* addonInstance, JOYSTICK_INFO* info);
+    PERIPHERAL_ERROR (__cdecl* get_features)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick, const char* controller_id, unsigned int* feature_count, JOYSTICK_FEATURE** features);
+    void (__cdecl* free_features)(const AddonInstance_Peripheral* addonInstance, unsigned int feature_count, JOYSTICK_FEATURE* features);
+    PERIPHERAL_ERROR (__cdecl* map_features)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick, const char* controller_id, unsigned int feature_count, const JOYSTICK_FEATURE* features);
+    PERIPHERAL_ERROR (__cdecl* get_ignored_primitives)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick, unsigned int* feature_count, JOYSTICK_DRIVER_PRIMITIVE** primitives);
+    void (__cdecl* free_primitives)(const AddonInstance_Peripheral* addonInstance, unsigned int, JOYSTICK_DRIVER_PRIMITIVE* primitives);
+    PERIPHERAL_ERROR (__cdecl* set_ignored_primitives)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick, unsigned int primitive_count, const JOYSTICK_DRIVER_PRIMITIVE* primitives);
+    void (__cdecl* save_button_map)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick);
+    void (__cdecl* revert_button_map)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick);
+    void (__cdecl* reset_button_map)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick, const char* controller_id);
+    void (__cdecl* power_off_joystick)(const AddonInstance_Peripheral* addonInstance, unsigned int index);
+    ///}
+  } KodiToAddonFuncTable_Peripheral;
+
+  typedef struct AddonInstance_Peripheral
+  {
+    AddonProps_Peripheral props;
+    AddonToKodiFuncTable_Peripheral toKodi;
+    KodiToAddonFuncTable_Peripheral toAddon;
+  } AddonInstance_Peripheral;
+
+} /* extern "C" */
+
+namespace kodi
+{
+namespace addon
+{
+
+  class CInstancePeripheral : public IAddonInstance
+  {
+  public:
+    CInstancePeripheral()
+      : IAddonInstance(ADDON_INSTANCE_PERIPHERAL)
+    {
+      if (CAddonBase::m_interface->globalSingleInstance != nullptr)
+        throw std::logic_error("kodi::addon::CInstancePeripheral: Creation of more as one in single instance way is not allowed!");
+
+      SetAddonStruct(CAddonBase::m_interface->firstKodiInstance);
+      CAddonBase::m_interface->globalSingleInstance = this;
+    }
+
+    CInstancePeripheral(KODI_HANDLE instance)
+      : IAddonInstance(ADDON_INSTANCE_PERIPHERAL)
+    {
+      if (CAddonBase::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;
+
+    /// @name Peripheral operations
+    ///{
+    /*!
+     * @brief Get the list of features that this add-on provides
+     * @param capabilities The add-on's capabilities.
+     * @remarks Valid implementation required.
+     *
+     * Called by the frontend to query the add-on's capabilities and supported
+     * peripherals. All capabilities that the add-on supports should be set to true.
+     *
+     */
+    virtual void GetCapabilities(PERIPHERAL_CAPABILITIES &capabilities) { }
+
+    /*!
+     * @brief Perform a scan for joysticks
+     * @param peripheral_count  Assigned to the number of peripherals allocated
+     * @param scan_results      Assigned to allocated memory
+     * @return PERIPHERAL_NO_ERROR if successful; peripherals must be freed using
+     * FreeScanResults() in this case
+     *
+     * The frontend calls this when a hardware change is detected. If an add-on
+     * detects a hardware change, it can trigger this function using the
+     * TriggerScan() callback.
+     */
+    virtual PERIPHERAL_ERROR PerformDeviceScan(unsigned int* peripheral_count, PERIPHERAL_INFO** scan_results) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Free the memory allocated in PerformDeviceScan()
+     *
+     * Must be called if PerformDeviceScan() returns PERIPHERAL_NO_ERROR.
+     *
+     * @param peripheral_count  The number of events allocated for the events array
+     * @param scan_results      The array of allocated peripherals
+     */
+    virtual void FreeScanResults(unsigned int peripheral_count, PERIPHERAL_INFO* scan_results) { }
+
+    /*!
+     * @brief Get all events that have occurred since the last call to GetEvents()
+     * @return PERIPHERAL_NO_ERROR if successful; events must be freed using
+     * FreeEvents() in this case
+     */
+    virtual PERIPHERAL_ERROR GetEvents(unsigned int* event_count, PERIPHERAL_EVENT** events) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Free the memory allocated in GetEvents()
+     *
+     * Must be called if GetEvents() returns PERIPHERAL_NO_ERROR.
+     *
+     * @param event_count  The number of events allocated for the events array
+     * @param events       The array of allocated events
+     */
+    virtual void FreeEvents(unsigned int event_count, PERIPHERAL_EVENT* events) { }
+
+    /*!
+     * @brief Send an input event to the specified peripheral
+     * @param peripheralIndex The index of the device receiving the input event
+     * @param event The input event
+     * @return true if the event was handled, false otherwise
+     */
+    virtual bool SendEvent(const PERIPHERAL_EVENT* event) { return false; }
+    ///}
+
+    /// @name Joystick operations
+    /*!
+     * @note #define PERIPHERAL_ADDON_JOYSTICKS before including kodi_peripheral_dll.h
+     * in the add-on if the add-on provides joysticks and add provides_joysticks="true"
+     * to the kodi.peripheral extension point node in addon.xml.
+     */
+    ///{
+    /*!
+     * @brief Get extended info about an attached joystick
+     * @param index  The joystick's driver index
+     * @param info   The container for the allocated joystick info
+     * @return PERIPHERAL_NO_ERROR if successful; array must be freed using
+     *         FreeJoystickInfo() in this case
+     */
+    virtual PERIPHERAL_ERROR GetJoystickInfo(unsigned int index, JOYSTICK_INFO* info) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Free the memory allocated in GetJoystickInfo()
+     */
+    virtual void FreeJoystickInfo(JOYSTICK_INFO* info) { }
+
+    /*!
+     * @brief Get the features that allow translating the joystick into the controller profile
+     * @param joystick      The device's joystick properties; unknown values may be left at their default
+     * @param controller_id The controller profile being requested, e.g. game.controller.default
+     * @param feature_count The number of features allocated for the features array
+     * @param features      The array of allocated features
+     * @return PERIPHERAL_NO_ERROR if successful; array must be freed using
+     *         FreeButtonMap() in this case
+     */
+    virtual PERIPHERAL_ERROR GetFeatures(const JOYSTICK_INFO* joystick, const char* controller_id,
+                                         unsigned int* feature_count, JOYSTICK_FEATURE** features) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Free the memory allocated in GetFeatures()
+     *
+     * Must be called if GetFeatures() returns PERIPHERAL_NO_ERROR.
+     *
+     * @param feature_count  The number of features allocated for the features array
+     * @param features       The array of allocated features
+     */
+    virtual void FreeFeatures(unsigned int feature_count, JOYSTICK_FEATURE* features) { }
+
+    /*!
+     * @brief Add or update joystick features
+     * @param joystick      The device's joystick properties; unknown values may be left at their default
+     * @param controller_id The game controller profile being updated
+     * @param feature_count The number of features in the features array
+     * @param features      The array of features
+     * @return PERIPHERAL_NO_ERROR if successful
+     */
+    virtual PERIPHERAL_ERROR MapFeatures(const JOYSTICK_INFO* joystick, const char* controller_id,
+                                         unsigned int feature_count, const JOYSTICK_FEATURE* features) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Get the driver primitives that should be ignored while mapping the device
+     * @param joystick        The device's joystick properties; unknown values may be left at their default
+     * @param primitive_count The number of features allocated for the primitives array
+     * @param primitives      The array of allocated driver primitives to be ignored
+     * @return PERIPHERAL_NO_ERROR if successful; array must be freed using
+     *         FreePrimitives() in this case
+     */
+    virtual PERIPHERAL_ERROR GetIgnoredPrimitives(const JOYSTICK_INFO* joystick,
+                                                  unsigned int* primitive_count,
+                                                  JOYSTICK_DRIVER_PRIMITIVE** primitives) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Free the memory allocated in GetIgnoredPrimitives()
+     *
+     * Must be called if GetIgnoredPrimitives() returns PERIPHERAL_NO_ERROR.
+     *
+     * @param primitive_count  The number of driver primitives allocated for the primitives array
+     * @param primitives       The array of allocated driver primitives
+     */
+    virtual void FreePrimitives(unsigned int primitive_count, JOYSTICK_DRIVER_PRIMITIVE* primitives) { }
+
+    /*!
+     * @brief Set the list of driver primitives that are ignored for the device
+     * @param joystick         The device's joystick properties; unknown values may be left at their default
+     * @param primitive_count  The number of driver features in the primitives array
+     * @param primitives       The array of driver primitives to ignore
+     * @return PERIPHERAL_NO_ERROR if successful
+     */
+    virtual PERIPHERAL_ERROR SetIgnoredPrimitives(const JOYSTICK_INFO* joystick,
+                                                  unsigned int primitive_count,
+                                                  const JOYSTICK_DRIVER_PRIMITIVE* primitives) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Save the button map for the given joystick
+     * @param joystick      The device's joystick properties
+     */
+    virtual void SaveButtonMap(const JOYSTICK_INFO* joystick) { }
+
+    /*!
+     * @brief Revert the button map to the last time it was loaded or committed to disk
+     * @param joystick      The device's joystick properties
+     */
+    virtual void RevertButtonMap(const JOYSTICK_INFO* joystick) { }
+
+    /*!
+     * @brief Reset the button map for the given joystick and controller profile ID
+     * @param joystick      The device's joystick properties
+     * @param controller_id The game controller profile being reset
+     */
+    virtual void ResetButtonMap(const JOYSTICK_INFO* joystick, const char* controller_id) { }
+
+    /*!
+     * @brief Powers off the given joystick if supported
+     * @param index  The joystick's driver index
+     */
+    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;
+    }
+
+    /*!
+     * @brief Trigger a scan for peripherals
+     *
+     * The add-on calls this if a change in hardware is detected.
+     */
+    void TriggerScan(void)
+    {
+      return m_instanceData->toKodi.trigger_scan(m_instanceData->toKodi.kodiInstance);
+    }
+
+    /*!
+     * @brief Notify the frontend that button maps have changed
+     *
+     * @param[optional] deviceName The name of the device to refresh, or empty/null for all devices
+     * @param[optional] controllerId The controller ID to refresh, or empty/null for all controllers
+     */
+    void RefreshButtonMaps(const std::string& strDeviceName = "", const std::string& strControllerId = "")
+    {
+      return m_instanceData->toKodi.refresh_button_maps(m_instanceData->toKodi.kodiInstance, strDeviceName.c_str(), strControllerId.c_str());
+    }
+
+    /*!
+     * @brief Return the number of features belonging to the specified controller
+     *
+     * @param controllerId    The controller ID to enumerate
+     * @param type[optional]  Type to filter by, or JOYSTICK_FEATURE_TYPE_UNKNOWN for all features
+     *
+     * @return The number of features matching the request parameters
+     */
+    unsigned int FeatureCount(const std::string& strControllerId, JOYSTICK_FEATURE_TYPE type = JOYSTICK_FEATURE_TYPE_UNKNOWN)
+    {
+      return m_instanceData->toKodi.feature_count(m_instanceData->toKodi.kodiInstance, strControllerId.c_str(), type);
+    }
+
+  private:
+    void SetAddonStruct(KODI_HANDLE instance)
+    {
+      if (instance == nullptr)
+        throw std::logic_error("kodi::addon::CInstancePeripheral: Creation with empty addon structure not allowed, table must be given from Kodi!");
+
+      m_instanceData = static_cast<AddonInstance_Peripheral*>(instance);
+      m_instanceData->toAddon.addonInstance = this;
+
+      m_instanceData->toAddon.get_capabilities = ADDON_GetCapabilities;
+      m_instanceData->toAddon.perform_device_scan = ADDON_PerformDeviceScan;
+      m_instanceData->toAddon.free_scan_results = ADDON_FreeScanResults;
+      m_instanceData->toAddon.get_events = ADDON_GetEvents;
+      m_instanceData->toAddon.free_events = ADDON_FreeEvents;
+      m_instanceData->toAddon.send_event = ADDON_SendEvent;
+
+      m_instanceData->toAddon.get_joystick_info = ADDON_GetJoystickInfo;
+      m_instanceData->toAddon.free_joystick_info = ADDON_FreeJoystickInfo;
+      m_instanceData->toAddon.get_features = ADDON_GetFeatures;
+      m_instanceData->toAddon.free_features = ADDON_FreeFeatures;
+      m_instanceData->toAddon.map_features = ADDON_MapFeatures;
+      m_instanceData->toAddon.get_ignored_primitives = ADDON_GetIgnoredPrimitives;
+      m_instanceData->toAddon.free_primitives = ADDON_FreePrimitives;
+      m_instanceData->toAddon.set_ignored_primitives = ADDON_SetIgnoredPrimitives;
+      m_instanceData->toAddon.save_button_map = ADDON_SaveButtonMap;
+      m_instanceData->toAddon.revert_button_map = ADDON_RevertButtonMap;
+      m_instanceData->toAddon.reset_button_map = ADDON_ResetButtonMap;
+      m_instanceData->toAddon.power_off_joystick = ADDON_PowerOffJoystick;
+    }
+
+    inline static void ADDON_GetCapabilities(const AddonInstance_Peripheral* addonInstance, PERIPHERAL_CAPABILITIES *capabilities)
+    {
+      addonInstance->toAddon.addonInstance->GetCapabilities(*capabilities);
+    }
+
+    inline static PERIPHERAL_ERROR ADDON_PerformDeviceScan(const AddonInstance_Peripheral* addonInstance, unsigned int* peripheral_count, PERIPHERAL_INFO** scan_results)
+    {
+      return addonInstance->toAddon.addonInstance->PerformDeviceScan(peripheral_count, scan_results);
+    }
+
+    inline static void ADDON_FreeScanResults(const AddonInstance_Peripheral* addonInstance, unsigned int peripheral_count, PERIPHERAL_INFO* scan_results)
+    {
+      addonInstance->toAddon.addonInstance->FreeScanResults(peripheral_count, scan_results);
+    }
+
+    inline static PERIPHERAL_ERROR ADDON_GetEvents(const AddonInstance_Peripheral* addonInstance, unsigned int* event_count, PERIPHERAL_EVENT** events)
+    {
+      return addonInstance->toAddon.addonInstance->GetEvents(event_count, events);
+    }
+
+    inline static void ADDON_FreeEvents(const AddonInstance_Peripheral* addonInstance, unsigned int event_count, PERIPHERAL_EVENT* events)
+    {
+      addonInstance->toAddon.addonInstance->FreeEvents(event_count, events);
+    }
+
+    inline static bool ADDON_SendEvent(const AddonInstance_Peripheral* addonInstance, const PERIPHERAL_EVENT* event)
+    {
+      return addonInstance->toAddon.addonInstance->SendEvent(event);
+    }
+
+    
+    inline static PERIPHERAL_ERROR ADDON_GetJoystickInfo(const AddonInstance_Peripheral* addonInstance, unsigned int index, JOYSTICK_INFO* info)
+    {
+      return addonInstance->toAddon.addonInstance->GetJoystickInfo(index, info);
+    }
+
+    inline static void ADDON_FreeJoystickInfo(const AddonInstance_Peripheral* addonInstance, JOYSTICK_INFO* info)
+    {
+      addonInstance->toAddon.addonInstance->FreeJoystickInfo(info);
+    }
+
+    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)
+    {
+      return addonInstance->toAddon.addonInstance->GetFeatures(joystick, controller_id, feature_count, features);
+    }
+
+    inline static void ADDON_FreeFeatures(const AddonInstance_Peripheral* addonInstance, unsigned int feature_count, JOYSTICK_FEATURE* features)
+    {
+      addonInstance->toAddon.addonInstance->FreeFeatures(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)
+    {
+      return addonInstance->toAddon.addonInstance->MapFeatures(joystick, controller_id, feature_count, features);
+    }
+
+    inline static PERIPHERAL_ERROR ADDON_GetIgnoredPrimitives(const AddonInstance_Peripheral* addonInstance,
+                                                              const JOYSTICK_INFO* joystick, unsigned int* primitive_count,
+                                                              JOYSTICK_DRIVER_PRIMITIVE** primitives)
+    {
+      return addonInstance->toAddon.addonInstance->GetIgnoredPrimitives(joystick, primitive_count, primitives);
+    }
+
+    inline static void ADDON_FreePrimitives(const AddonInstance_Peripheral* addonInstance,
+                                            unsigned int primitive_count, JOYSTICK_DRIVER_PRIMITIVE* primitives)
+    {
+      addonInstance->toAddon.addonInstance->FreePrimitives(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)
+    {
+      return addonInstance->toAddon.addonInstance->SetIgnoredPrimitives(joystick, primitive_count, primitives);
+    }
+
+    inline static void ADDON_SaveButtonMap(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick)
+    {
+      addonInstance->toAddon.addonInstance->SaveButtonMap(joystick);
+    }
+
+    inline static void ADDON_RevertButtonMap(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick)
+    {
+      addonInstance->toAddon.addonInstance->RevertButtonMap(joystick);
+    }
+
+    inline static void ADDON_ResetButtonMap(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick, const char* controller_id)
+    {
+      addonInstance->toAddon.addonInstance->ResetButtonMap(joystick, controller_id);
+    }
+
+    inline static void ADDON_PowerOffJoystick(const AddonInstance_Peripheral* addonInstance, unsigned int index)
+    {
+      addonInstance->toAddon.addonInstance->PowerOffJoystick(index);
+    }
+
+    AddonInstance_Peripheral* m_instanceData;
+  };
+
+} /* namespace addon */
+} /* namespace kodi */