InputManager.h

/*
 *  Copyright (C) 2005-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/actions/Action.h"
#include "input/actions/interfaces/IActionListener.h"
#include "input/keyboard/KeyboardStat.h"
#include "input/keymaps/ButtonStat.h"
#include "input/mouse/MouseStat.h"
#include "input/mouse/interfaces/IMouseInputProvider.h"
#include "settings/lib/ISettingCallback.h"
#include "threads/CriticalSection.h"
#include "utils/Observer.h"
#include "windowing/XBMC_events.h"

#include <map>
#include <memory>
#include <string>
#include <vector>

class CKey;
class CProfileManager;

namespace KODI
{

namespace KEYBOARD
{
class IKeyboardDriverHandler;
}

namespace KEYMAP
{
class CButtonTranslator;
class CCustomControllerTranslator;
class CJoystickMapper;
class CTouchTranslator;
class IKeymapEnvironment;
class IWindowKeymap;
} // namespace KEYMAP

namespace MOUSE
{
class IMouseDriverHandler;
}
} // namespace KODI


class CInputManager : public ISettingCallback,
                      public KODI::ACTION::IActionListener,
                      public Observable
{
public:
  CInputManager();
  CInputManager(const CInputManager&) = delete;
  CInputManager const& operator=(CInputManager const&) = delete;
  ~CInputManager() override;

  bool ProcessMouse(int windowId);

  bool ProcessEventServer(int windowId, float frameTime);

  bool ProcessPeripherals(float frameTime);

  bool Process(int windowId, float frameTime);

  void InitializeInputs();

  void Deinitialize();

  bool OnEvent(XBMC_Event& newEvent);

  void SetMouseActive(bool active = true);

  void SetMouseEnabled(bool mouseEnabled = true);

  void SetMouseState(MOUSE_STATE mouseState);

  bool IsMouseActive();

  MOUSE_STATE GetMouseState();

  MousePosition GetMousePosition();

  void SetMouseResolution(int maxX, int maxY, float speedX, float speedY);

  bool IsControllerEnabled() const;

  bool HasBuiltin(const std::string& command);

  int ExecuteBuiltin(const std::string& execute, const std::vector<std::string>& params);

  // Button translation
  bool LoadKeymaps();
  bool ReloadKeymaps();
  void ClearKeymaps();
  void AddKeymap(const std::string& keymap);
  void RemoveKeymap(const std::string& keymap);

  const KODI::KEYMAP::IKeymapEnvironment* KeymapEnvironment() const;

  CAction GetAction(int window, const CKey& key, bool fallback = true);

  bool TranslateCustomControllerString(int windowId,
                                       const std::string& controllerName,
                                       int buttonId,
                                       int& action,
                                       std::string& strAction);

  bool TranslateTouchAction(
      int windowId, int touchAction, int touchPointers, int& action, std::string& actionString);

  std::vector<std::shared_ptr<const KODI::KEYMAP::IWindowKeymap>> GetJoystickKeymaps() const;

  void QueueAction(const CAction& action);

  // implementation of ISettingCallback
  void OnSettingChanged(const std::shared_ptr<const CSetting>& setting) override;

  // implementation of IActionListener
  bool OnAction(const CAction& action) override;

  void RegisterKeyboardDriverHandler(KODI::KEYBOARD::IKeyboardDriverHandler* handler);
  void UnregisterKeyboardDriverHandler(KODI::KEYBOARD::IKeyboardDriverHandler* handler);

  virtual void RegisterMouseDriverHandler(KODI::MOUSE::IMouseDriverHandler* handler);
  virtual void UnregisterMouseDriverHandler(KODI::MOUSE::IMouseDriverHandler* handler);

private:
  bool OnKey(const CKey& key);

  void OnKeyUp(const CKey& key);

  bool HandleKey(const CKey& key);

  bool AlwaysProcess(const CAction& action);

  bool ExecuteInputAction(const CAction& action);

  void ProcessQueuedActions();

  KODI::KEYBOARD::CKeyboardStat m_Keyboard;
  KODI::KEYMAP::CButtonStat m_buttonStat;
  CMouseStat m_Mouse;
  CKey m_LastKey;

  std::map<std::string, std::map<int, float>> m_lastAxisMap;

  std::vector<CAction> m_queuedActions;
  CCriticalSection m_actionMutex;

  // Button translation
  std::unique_ptr<KODI::KEYMAP::IKeymapEnvironment> m_keymapEnvironment;
  std::unique_ptr<KODI::KEYMAP::CButtonTranslator> m_buttonTranslator;
  std::unique_ptr<KODI::KEYMAP::CCustomControllerTranslator> m_customControllerTranslator;
  std::unique_ptr<KODI::KEYMAP::CTouchTranslator> m_touchTranslator;
  std::unique_ptr<KODI::KEYMAP::CJoystickMapper> m_joystickTranslator;

  std::vector<KODI::KEYBOARD::IKeyboardDriverHandler*> m_keyboardHandlers;
  std::vector<KODI::MOUSE::IMouseDriverHandler*> m_mouseHandlers;

  std::unique_ptr<KODI::KEYBOARD::IKeyboardDriverHandler> m_keyboardEasterEgg;

  // Input state
  bool m_enableController = true;

  // Settings
  static const std::string SETTING_INPUT_ENABLE_CONTROLLER;
};