sensor_provider_impl.cc 5.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138
  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. #include "services/device/generic_sensor/sensor_provider_impl.h"
  5. #include <utility>
  6. #include "base/bind.h"
  7. #include "base/feature_list.h"
  8. #include "base/memory/ptr_util.h"
  9. #include "mojo/public/cpp/bindings/pending_remote.h"
  10. #include "services/device/generic_sensor/platform_sensor_provider.h"
  11. #include "services/device/generic_sensor/sensor_impl.h"
  12. #include "services/device/public/cpp/device_features.h"
  13. #include "services/device/public/cpp/generic_sensor/sensor_traits.h"
  14. namespace device {
  15. namespace {
  16. bool IsExtraSensorClass(mojom::SensorType type) {
  17. switch (type) {
  18. case mojom::SensorType::ACCELEROMETER:
  19. case mojom::SensorType::LINEAR_ACCELERATION:
  20. case mojom::SensorType::GRAVITY:
  21. case mojom::SensorType::GYROSCOPE:
  22. case mojom::SensorType::ABSOLUTE_ORIENTATION_EULER_ANGLES:
  23. case mojom::SensorType::ABSOLUTE_ORIENTATION_QUATERNION:
  24. case mojom::SensorType::RELATIVE_ORIENTATION_EULER_ANGLES:
  25. case mojom::SensorType::RELATIVE_ORIENTATION_QUATERNION:
  26. return false;
  27. default:
  28. return true;
  29. }
  30. }
  31. } // namespace
  32. SensorProviderImpl::SensorProviderImpl(
  33. std::unique_ptr<PlatformSensorProvider> provider)
  34. : provider_(std::move(provider)) {
  35. DCHECK(provider_);
  36. }
  37. SensorProviderImpl::~SensorProviderImpl() {}
  38. void SensorProviderImpl::Bind(
  39. mojo::PendingReceiver<mojom::SensorProvider> receiver) {
  40. receivers_.Add(this, std::move(receiver));
  41. }
  42. void SensorProviderImpl::GetSensor(mojom::SensorType type,
  43. GetSensorCallback callback) {
  44. if (!base::FeatureList::IsEnabled(features::kGenericSensorExtraClasses) &&
  45. IsExtraSensorClass(type)) {
  46. std::move(callback).Run(mojom::SensorCreationResult::ERROR_NOT_AVAILABLE,
  47. nullptr);
  48. return;
  49. }
  50. auto cloned_region = provider_->CloneSharedMemoryRegion();
  51. if (!cloned_region.IsValid()) {
  52. std::move(callback).Run(mojom::SensorCreationResult::ERROR_NOT_AVAILABLE,
  53. nullptr);
  54. return;
  55. }
  56. scoped_refptr<PlatformSensor> sensor = provider_->GetSensor(type);
  57. if (!sensor) {
  58. provider_->CreateSensor(
  59. type, base::BindOnce(&SensorProviderImpl::SensorCreated,
  60. weak_ptr_factory_.GetWeakPtr(), type,
  61. std::move(cloned_region), std::move(callback)));
  62. return;
  63. }
  64. SensorCreated(type, std::move(cloned_region), std::move(callback),
  65. std::move(sensor));
  66. }
  67. void SensorProviderImpl::SensorCreated(
  68. mojom::SensorType type,
  69. base::ReadOnlySharedMemoryRegion cloned_region,
  70. GetSensorCallback callback,
  71. scoped_refptr<PlatformSensor> sensor) {
  72. if (!sensor) {
  73. std::move(callback).Run(mojom::SensorCreationResult::ERROR_NOT_AVAILABLE,
  74. nullptr);
  75. return;
  76. }
  77. auto init_params = mojom::SensorInitParams::New();
  78. auto sensor_impl = std::make_unique<SensorImpl>(sensor);
  79. init_params->client_receiver = sensor_impl->GetClient();
  80. mojo::PendingRemote<mojom::Sensor> pending_sensor;
  81. sensor_receivers_.Add(std::move(sensor_impl),
  82. pending_sensor.InitWithNewPipeAndPassReceiver());
  83. init_params->sensor = std::move(pending_sensor);
  84. init_params->memory = std::move(cloned_region);
  85. init_params->buffer_offset = SensorReadingSharedBuffer::GetOffset(type);
  86. init_params->mode = sensor->GetReportingMode();
  87. double maximum_frequency = sensor->GetMaximumSupportedFrequency();
  88. DCHECK_GT(maximum_frequency, 0.0);
  89. double minimum_frequency = sensor->GetMinimumSupportedFrequency();
  90. DCHECK_GT(minimum_frequency, 0.0);
  91. const double maximum_allowed_frequency = GetSensorMaxAllowedFrequency(type);
  92. if (maximum_frequency > maximum_allowed_frequency)
  93. maximum_frequency = maximum_allowed_frequency;
  94. // These checks are to make sure the following assertion is still true:
  95. // 'minimum_frequency <= default_frequency <= maximum_frequency'
  96. // after we capped the maximium frequency to the value from traits
  97. // (and also in case platform gave us some wacky values).
  98. if (minimum_frequency > maximum_frequency)
  99. minimum_frequency = maximum_frequency;
  100. auto default_configuration = sensor->GetDefaultConfiguration();
  101. if (default_configuration.frequency() > maximum_frequency)
  102. default_configuration.set_frequency(maximum_frequency);
  103. if (default_configuration.frequency() < minimum_frequency)
  104. default_configuration.set_frequency(minimum_frequency);
  105. init_params->default_configuration = default_configuration;
  106. init_params->maximum_frequency = maximum_frequency;
  107. init_params->minimum_frequency = sensor->GetMinimumSupportedFrequency();
  108. DCHECK_GT(init_params->minimum_frequency, 0.0);
  109. DCHECK_GE(init_params->maximum_frequency, init_params->minimum_frequency);
  110. std::move(callback).Run(mojom::SensorCreationResult::SUCCESS,
  111. std::move(init_params));
  112. }
  113. } // namespace device