ButtonMapping.h

/*
 *  Copyright (C) 2014-2024 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 "input/joysticks/DriverPrimitive.h"
#include "input/joysticks/interfaces/IButtonMapCallback.h"
#include "input/joysticks/interfaces/IDriverHandler.h"
#include "input/keyboard/interfaces/IKeyboardDriverHandler.h"
#include "input/mouse/MouseTypes.h"
#include "input/mouse/interfaces/IMouseDriverHandler.h"

#include <chrono>
#include <map>
#include <memory>
#include <stdint.h>

namespace KODI
{
namespace KEYMAP
{
class IKeymap;
} // namespace KEYMAP

namespace JOYSTICK
{
class CButtonMapping;
class IButtonMap;
class IButtonMapper;

class CPrimitiveDetector
{
protected:
  CPrimitiveDetector(CButtonMapping* buttonMapping);

  bool MapPrimitive(const CDriverPrimitive& primitive);

private:
  CButtonMapping* const m_buttonMapping;
};

class CButtonDetector : public CPrimitiveDetector
{
public:
  CButtonDetector(CButtonMapping* buttonMapping, unsigned int buttonIndex);

  bool OnMotion(bool bPressed);

private:
  // Construction parameters
  const unsigned int m_buttonIndex;
};

class CHatDetector : public CPrimitiveDetector
{
public:
  CHatDetector(CButtonMapping* buttonMapping, unsigned int hatIndex);

  bool OnMotion(HAT_STATE state);

private:
  // Construction parameters
  const unsigned int m_hatIndex;
};

struct AxisConfiguration
{
  bool bKnown = false;
  int center = 0;
  unsigned int range = 1;
  bool bLateDiscovery = false;
};

class CAxisDetector : public CPrimitiveDetector
{
public:
  CAxisDetector(CButtonMapping* buttonMapping,
                unsigned int axisIndex,
                const AxisConfiguration& config);

  bool OnMotion(float position);

  void ProcessMotion();

  bool IsMapping() const { return m_state == AXIS_STATE::MAPPED; }

  void SetEmitted(const CDriverPrimitive& activePrimitive);

private:
  enum class AXIS_STATE
  {
    INACTIVE,

    ACTIVATED,

    MAPPED,
  };

  enum class AXIS_TYPE
  {
    UNKNOWN,

    NORMAL,

    OFFSET,
  };

  void DetectType(float position);

  // Construction parameters
  const unsigned int m_axisIndex;
  AxisConfiguration m_config; // mutable

  // State variables
  AXIS_STATE m_state = AXIS_STATE::INACTIVE;
  CDriverPrimitive m_activatedPrimitive;
  AXIS_TYPE m_type = AXIS_TYPE::UNKNOWN;
  bool m_initialPositionKnown = false; // set to true on first motion
  float m_initialPosition = 0.0f; // set to position of first motion
  bool m_initialPositionChanged =
      false; // set to true when position differs from the initial position
  std::chrono::time_point<std::chrono::steady_clock>
      m_activationTimeMs; // only used to delay anomalous trigger mapping to detect full range
};

class CKeyDetector : public CPrimitiveDetector
{
public:
  CKeyDetector(CButtonMapping* buttonMapping, XBMCKey keycode);

  bool OnMotion(bool bPressed);

private:
  // Construction parameters
  const XBMCKey m_keycode;
};

class CMouseButtonDetector : public CPrimitiveDetector
{
public:
  CMouseButtonDetector(CButtonMapping* buttonMapping, MOUSE::BUTTON_ID buttonIndex);

  bool OnMotion(bool bPressed);

private:
  // Construction parameters
  const MOUSE::BUTTON_ID m_buttonIndex;
};

class CPointerDetector : public CPrimitiveDetector
{
public:
  CPointerDetector(CButtonMapping* buttonMapping);

  bool OnMotion(int x, int y);

private:
  // Utility function
  static INPUT::INTERCARDINAL_DIRECTION GetPointerDirection(int x, int y);

  static const unsigned int MIN_FRAME_COUNT = 10;

  // State variables
  bool m_bStarted = false;
  int m_startX = 0;
  int m_startY = 0;
  unsigned int m_frameCount = 0;
};

class CButtonMapping : public IDriverHandler,
                       public KEYBOARD::IKeyboardDriverHandler,
                       public MOUSE::IMouseDriverHandler,
                       public IButtonMapCallback
{
public:
  CButtonMapping(IButtonMapper* buttonMapper, IButtonMap* buttonMap, KEYMAP::IKeymap* keymap);

  ~CButtonMapping() override = default;

  // implementation of IDriverHandler
  bool OnButtonMotion(unsigned int buttonIndex, bool bPressed) override;
  bool OnHatMotion(unsigned int hatIndex, HAT_STATE state) override;
  bool OnAxisMotion(unsigned int axisIndex,
                    float position,
                    int center,
                    unsigned int range) override;
  void OnInputFrame() override;

  // implementation of IKeyboardDriverHandler
  bool OnKeyPress(const CKey& key) override;
  void OnKeyRelease(const CKey& key) override {}

  // implementation of IMouseDriverHandler
  bool OnPosition(int x, int y) override;
  bool OnButtonPress(MOUSE::BUTTON_ID button) override;
  void OnButtonRelease(MOUSE::BUTTON_ID button) override;

  // implementation of IButtonMapCallback
  void SaveButtonMap() override;
  void ResetIgnoredPrimitives() override;
  void RevertButtonMap() override;

  bool MapPrimitive(const CDriverPrimitive& primitive);

private:
  bool IsMapping() const;

  void OnLateDiscovery(unsigned int axisIndex);

  CButtonDetector& GetButton(unsigned int buttonIndex);
  CHatDetector& GetHat(unsigned int hatIndex);
  CAxisDetector& GetAxis(unsigned int axisIndex,
                         float position,
                         const AxisConfiguration& initialConfig = AxisConfiguration());
  CKeyDetector& GetKey(XBMCKey keycode);
  CMouseButtonDetector& GetMouseButton(MOUSE::BUTTON_ID buttonIndex);
  CPointerDetector& GetPointer();

  // Construction parameters
  IButtonMapper* const m_buttonMapper;
  IButtonMap* const m_buttonMap;
  KEYMAP::IKeymap* const m_keymap;

  std::map<unsigned int, CButtonDetector> m_buttons;
  std::map<unsigned int, CHatDetector> m_hats;
  std::map<unsigned int, CAxisDetector> m_axes;
  std::map<XBMCKey, CKeyDetector> m_keys;
  std::map<MOUSE::BUTTON_ID, CMouseButtonDetector> m_mouseButtons;
  std::unique_ptr<CPointerDetector> m_pointer;
  std::chrono::time_point<std::chrono::steady_clock> m_lastAction;
  uint64_t m_frameCount = 0;
};
} // namespace JOYSTICK
} // namespace KODI