PeripheralBus.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 "peripherals/PeripheralTypes.h"
#include "threads/Thread.h"

#include <memory>
#include <mutex>
#include <vector>

class CFileItemList;

namespace PERIPHERALS
{
class CPeripheral;
class CPeripherals;

class CPeripheralBus : protected CThread
{
public:
  CPeripheralBus(const std::string& threadname, CPeripherals& manager, PeripheralBusType type);
  ~CPeripheralBus(void) override { Clear(); }

  PeripheralBusType Type(void) const { return m_type; }

  bool NeedsPolling(void) const
  {
    std::unique_lock<CCriticalSection> lock(m_critSection);
    return m_bNeedsPolling;
  }

  virtual bool InitializeProperties(CPeripheral& peripheral);

  virtual PeripheralPtr GetPeripheral(const std::string& strLocation) const;

  virtual bool HasPeripheral(const std::string& strLocation) const;

  virtual bool SupportsFeature(PeripheralFeature feature) const { return false; }

  virtual unsigned int GetPeripheralsWithFeature(PeripheralVector& results,
                                                 const PeripheralFeature feature) const;

  virtual unsigned int GetNumberOfPeripherals() const;
  virtual unsigned int GetNumberOfPeripheralsWithId(const int iVendorId,
                                                    const int iProductId) const;

  virtual void GetFeatures(std::vector<PeripheralFeature>& features) const;

  virtual bool HasFeature(const PeripheralFeature feature) const;

  virtual void OnDeviceAdded(const std::string& strLocation);

  virtual void OnDeviceChanged(const std::string& strLocation);

  virtual void OnDeviceRemoved(const std::string& strLocation);

  virtual void Initialise(void);

  virtual void Clear(void);

  virtual void TriggerDeviceScan(void);

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

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

  virtual void Register(const PeripheralPtr& peripheral);

  virtual bool FindComPort(std::string& strLocation) { return false; }

  virtual void ProcessEvents(void) {}

  virtual void EnableButtonMapping() {}

  virtual void PowerOff(const std::string& strLocation) {}

protected:
  void Process(void) override;
  virtual bool ScanForDevices(void);
  virtual void UnregisterRemovedDevices(const PeripheralScanResults& results);
  virtual void RegisterNewDevices(const PeripheralScanResults& results);

  virtual bool PerformDeviceScan(PeripheralScanResults& results) = 0;

  PeripheralVector m_peripherals;
  std::chrono::milliseconds m_iRescanTime;
  bool m_bNeedsPolling =
      true; 
  CPeripherals& m_manager;
  const PeripheralBusType m_type;
  mutable CCriticalSection m_critSection;
  CEvent m_triggerEvent;
};
using PeripheralBusPtr = std::shared_ptr<CPeripheralBus>;
using PeripheralBusVector = std::vector<PeripheralBusPtr>;
} // namespace PERIPHERALS