sensor_device_manager.h 3.1 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889
  1. // Copyright 2016 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #ifndef SERVICES_DEVICE_GENERIC_SENSOR_LINUX_SENSOR_DEVICE_MANAGER_H_
  5. #define SERVICES_DEVICE_GENERIC_SENSOR_LINUX_SENSOR_DEVICE_MANAGER_H_
  6. #include <memory>
  7. #include "base/memory/weak_ptr.h"
  8. #include "base/sequence_checker.h"
  9. #include "base/task/sequenced_task_runner.h"
  10. #include "device/udev_linux/udev_watcher.h"
  11. #include "services/device/public/mojom/sensor.mojom.h"
  12. namespace device {
  13. struct SensorInfoLinux;
  14. // Monitors udev added/removed events and enumerates existing sensor devices;
  15. // after processing, notifies its |Delegate|. It has own cache to speed up an
  16. // identification process of removed devices.
  17. // Start() must run in a task runner that can block.
  18. class SensorDeviceManager : public UdevWatcher::Observer {
  19. public:
  20. class Delegate {
  21. public:
  22. // Called when SensorDeviceManager has enumerated through all possible
  23. // iio udev devices.
  24. virtual void OnSensorNodesEnumerated() = 0;
  25. // Called after SensorDeviceManager has identified a udev device, which
  26. // belongs to "iio" subsystem.
  27. virtual void OnDeviceAdded(mojom::SensorType type,
  28. std::unique_ptr<SensorInfoLinux> sensor) = 0;
  29. // Called after "removed" event is received from LinuxDeviceMonitor and
  30. // sensor is identified as known.
  31. virtual void OnDeviceRemoved(mojom::SensorType type,
  32. const std::string& device_node) = 0;
  33. protected:
  34. virtual ~Delegate() {}
  35. };
  36. explicit SensorDeviceManager(base::WeakPtr<Delegate> delegate);
  37. SensorDeviceManager(const SensorDeviceManager&) = delete;
  38. SensorDeviceManager& operator=(const SensorDeviceManager&) = delete;
  39. ~SensorDeviceManager() override;
  40. // Starts monitoring sensor-related udev events, and enumerates existing
  41. // sensors. This method must be run from a task runner that can block.
  42. virtual void Start();
  43. protected:
  44. using SensorDeviceMap = std::unordered_map<std::string, mojom::SensorType>;
  45. // Wrappers around udev system methods that can be implemented differently
  46. // by tests.
  47. virtual std::string GetUdevDeviceGetSubsystem(udev_device* dev);
  48. virtual std::string GetUdevDeviceGetSyspath(udev_device* dev);
  49. virtual std::string GetUdevDeviceGetSysattrValue(
  50. udev_device* dev,
  51. const std::string& attribute);
  52. virtual std::string GetUdevDeviceGetDevnode(udev_device* dev);
  53. // UdevWatcher::Observer overrides
  54. void OnDeviceAdded(ScopedUdevDevicePtr udev_device) override;
  55. void OnDeviceRemoved(ScopedUdevDevicePtr device) override;
  56. void OnDeviceChanged(ScopedUdevDevicePtr device) override;
  57. // Represents a map of sensors that are already known to this manager after
  58. // initial enumeration.
  59. SensorDeviceMap sensors_by_node_;
  60. SEQUENCE_CHECKER(sequence_checker_);
  61. std::unique_ptr<UdevWatcher> udev_watcher_;
  62. base::WeakPtr<Delegate> delegate_;
  63. scoped_refptr<base::SequencedTaskRunner> delegate_task_runner_;
  64. };
  65. } // namespace device
  66. #endif // SERVICES_DEVICE_GENERIC_SENSOR_LINUX_SENSOR_DEVICE_MANAGER_H_