Peripherals.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 "IEventScannerCallback.h"
#include "bus/PeripheralBus.h"
#include "devices/Peripheral.h"
#include "interfaces/IAnnouncer.h"
#include "messaging/IMessageTarget.h"
#include "settings/lib/ISettingCallback.h"
#include "threads/CriticalSection.h"
#include "threads/Thread.h"
#include "utils/Observer.h"

#include <memory>
#include <vector>

class CFileItemList;
class CInputManager;
class CSetting;
class CSettingsCategory;
class TiXmlElement;
class CAction;
class CKey;

namespace KODI
{
namespace GAME
{
class CControllerManager;
}

namespace JOYSTICK
{
class IButtonMapper;
}
} // namespace KODI

namespace PERIPHERALS
{
class CEventScanner;

class CPeripherals : public ISettingCallback,
                     public Observable,
                     public KODI::MESSAGING::IMessageTarget,
                     public IEventScannerCallback,
                     public ANNOUNCEMENT::IAnnouncer
{
public:
  explicit CPeripherals(CInputManager& inputManager,
                        KODI::GAME::CControllerManager& controllerProfiles);

  ~CPeripherals() override;

  void Initialise();

  void Clear();

  PeripheralPtr GetPeripheralAtLocation(const std::string& strLocation,
                                        PeripheralBusType busType = PERIPHERAL_BUS_UNKNOWN) const;

  bool HasPeripheralAtLocation(const std::string& strLocation,
                               PeripheralBusType busType = PERIPHERAL_BUS_UNKNOWN) const;

  PeripheralBusPtr GetBusWithDevice(const std::string& strLocation) const;

  bool SupportsFeature(PeripheralFeature feature) const;

  int GetPeripheralsWithFeature(PeripheralVector& results,
                                const PeripheralFeature feature,
                                PeripheralBusType busType = PERIPHERAL_BUS_UNKNOWN) const;

  size_t GetNumberOfPeripherals() const;

  bool HasPeripheralWithFeature(const PeripheralFeature feature,
                                PeripheralBusType busType = PERIPHERAL_BUS_UNKNOWN) const;

  void OnDeviceAdded(const CPeripheralBus& bus, const CPeripheral& peripheral);

  void OnDeviceDeleted(const CPeripheralBus& bus, const CPeripheral& peripheral);

  void CreatePeripheral(CPeripheralBus& bus, const PeripheralScanResult& result);

  void GetSettingsFromMapping(CPeripheral& peripheral) const;

  void TriggerDeviceScan(const PeripheralBusType type = PERIPHERAL_BUS_UNKNOWN);

  PeripheralBusPtr GetBusByType(const PeripheralBusType type) const;

  void GetDirectory(const std::string& strPath, CFileItemList& items) const;

  PeripheralPtr GetByPath(const std::string& strPath) const;

  bool OnAction(const CAction& action);

  bool IsMuted();

  bool ToggleMute();

  bool ToggleDeviceState(const CecStateChange mode = STATE_SWITCH_TOGGLE);

  bool Mute()
  {
    return ToggleMute();
  } 

  bool UnMute()
  {
    return ToggleMute();
  } 

  bool GetNextKeypress(float frameTime, CKey& key);

  EventPollHandlePtr RegisterEventPoller();

  EventLockHandlePtr RegisterEventLock();

  void OnUserNotification();

  void TestFeature(PeripheralFeature feature);

  void PowerOffDevices();

  bool SupportsCEC() const
  {
#if defined(HAVE_LIBCEC)
    return true;
#else
    return false;
#endif
  }

  // implementation of IEventScannerCallback
  void ProcessEvents(void) override;

  void EnableButtonMapping();

  PeripheralAddonPtr GetAddonWithButtonMap(const CPeripheral* device);

  void ResetButtonMaps(const std::string& controllerId);

  void RegisterJoystickButtonMapper(KODI::JOYSTICK::IButtonMapper* mapper);

  void UnregisterJoystickButtonMapper(KODI::JOYSTICK::IButtonMapper* mapper);

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

  // implementation of IMessageTarget
  void OnApplicationMessage(KODI::MESSAGING::ThreadMessage* pMsg) override;
  int GetMessageMask() override;

  // implementation of IAnnouncer
  void Announce(ANNOUNCEMENT::AnnouncementFlag flag,
                const std::string& sender,
                const std::string& message,
                const CVariant& data) override;

  CInputManager& GetInputManager() { return m_inputManager; }

  KODI::GAME::CControllerManager& GetControllerProfiles() { return m_controllerProfiles; }

private:
  bool LoadMappings();
  bool GetMappingForDevice(const CPeripheralBus& bus, PeripheralScanResult& result) const;
  static void GetSettingsFromMappingsFile(
      TiXmlElement* xmlNode, std::map<std::string, PeripheralDeviceSetting>& m_settings);

  void OnDeviceChanged();

  // Construction parameters
  CInputManager& m_inputManager;
  KODI::GAME::CControllerManager& m_controllerProfiles;

#if !defined(HAVE_LIBCEC)
  bool m_bMissingLibCecWarningDisplayed = false;
#endif
  std::vector<PeripheralBusPtr> m_busses;
  std::vector<PeripheralDeviceMapping> m_mappings;
  std::unique_ptr<CEventScanner> m_eventScanner;
  mutable CCriticalSection m_critSectionBusses;
  mutable CCriticalSection m_critSectionMappings;
};
} // namespace PERIPHERALS