ash/sensor_info/sensor_provider.cc - chromium/src - Git at Google

 // Copyright 2023 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "ash/sensor_info/sensor_provider.h"

 #include <cstddef>
 #include <iterator>
 #include <utility>

 #include "ash/sensor_info/sensor_types.h"
 #include "base/containers/contains.h"
 #include "base/functional/bind.h"
 #include "base/ranges/algorithm.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "chromeos/components/sensors/ash/sensor_hal_dispatcher.h"
 #include "chromeos/components/sensors/mojom/sensor.mojom.h"

 namespace ash {

 using ::chromeos::sensors::mojom::DeviceType;

 namespace {

 // Delay of the reconnection to Sensor Hal Dispatcher.
 constexpr base::TimeDelta kDelayReconnect = base::Seconds(1);

 // Timeout for getting lid_angle samples.
 constexpr base::TimeDelta kLidAngleTimeout = base::Seconds(1);

 constexpr double kReadFrequencyInHz = 100.0;

 }  // namespace

 SensorProvider::DeviceState::DeviceState() {
   for (int index = 0; index < static_cast<int>(SensorType::kSensorTypeCount);
        ++index) {
     present_.push_back(false);
   }
 }

 SensorProvider::DeviceState::~DeviceState() = default;

 bool SensorProvider::DeviceState::AllSensorsFound() const {
   for (int index = 0; index < static_cast<int>(SensorType::kSensorTypeCount);
        ++index) {
     if (!present_[index]) {
       return false;
     }
   }
   return true;
 }

 void SensorProvider::DeviceState::Reset() {
   for (int index = 0; index < static_cast<int>(SensorType::kSensorTypeCount);
        ++index) {
     present_[index] = false;
   }
 }

 bool SensorProvider::DeviceState::CompareUpdate(SensorUpdate update) const {
   for (int index = 0; index < static_cast<int>(SensorType::kSensorTypeCount);
        ++index) {
     auto source = static_cast<SensorType>(index);
     if (!present_[index]) {
       if (update.has(source)) {
         LOG(ERROR) << "SensorUpdate has extra source: "
                    << static_cast<int>(source);
       }
       continue;
     }
     if (update.has(source)) {
       continue;
     }
     return false;
   }
   return true;
 }

 void SensorProvider::DeviceState::AddSource(SensorType source) {
   present_[static_cast<int>(source)] = true;
 }

 void SensorProvider::DeviceState::RemoveSource(SensorType source) {
   present_[static_cast<int>(source)] = false;
 }

 bool SensorProvider::DeviceState::GetSource(SensorType source) const {
   return present_[static_cast<int>(source)];
 }

 std::vector<bool> SensorProvider::DeviceState::GetStatesForTesting() const {
   return present_;
 }

 SensorProvider::SensorData::SensorData() = default;
 SensorProvider::SensorData::~SensorData() = default;

 SensorProvider::SensorProvider() {
   RegisterSensorClient();
 }

 SensorProvider::~SensorProvider() = default;

 void SensorProvider::SetUpChannel(
     mojo::PendingRemote<chromeos::sensors::mojom::SensorService>
         pending_remote) {
   if (sensor_service_remote_.is_bound()) {
     LOG(ERROR) << "Ignoring the second Remote<SensorService>";
     return;
   }

   sensor_service_remote_.Bind(std::move(pending_remote));
   sensor_service_remote_.set_disconnect_handler(
       base::BindOnce(&SensorProvider::OnSensorServiceDisconnect,
                      weak_ptr_factory_.GetWeakPtr()));
   SetNewDevicesObserver();

   QueryDevices();
 }

 void SensorProvider::OnSensorServiceDisconnect() {
   LOG(ERROR) << "OnSensorServiceDisconnect";

   ResetSensorService();
 }

 std::vector<bool> SensorProvider::GetStateForTesting() {
   return current_state_.GetStatesForTesting();  // IN-TEST
 }

 void SensorProvider::OnNewDeviceAdded(int32_t iio_device_id,
                                       const std::vector<DeviceType>& types) {
   for (const auto& type : types) {
     if (type == DeviceType::ACCEL || type == DeviceType::ANGL ||
         type == DeviceType::ANGLVEL) {
       RegisterSensor(type, iio_device_id);
     }
   }
 }

 void SensorProvider::RegisterSensorClient() {
   auto* dispatcher = chromeos::sensors::SensorHalDispatcher::GetInstance();
   if (!dispatcher) {
     // In unit tests, SensorHalDispatcher is not initialized.
     return;
   }

   dispatcher->RegisterClient(sensor_hal_client_.BindNewPipeAndPassRemote());

   sensor_hal_client_.set_disconnect_handler(
       base::BindOnce(&SensorProvider::OnSensorHalClientFailure,
                      weak_ptr_factory_.GetWeakPtr()));
 }

 void SensorProvider::OnSensorHalClientFailure() {
   LOG(ERROR) << "OnSensorHalClientFailure";

   ResetSensorService();
   sensor_hal_client_.reset();
   // It's expected that SensorHalDispatcher will restart after failure,
   // so it's OK to retry forever here.
   base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
       FROM_HERE,
       base::BindOnce(&SensorProvider::RegisterSensorClient,
                      weak_ptr_factory_.GetWeakPtr()),
       kDelayReconnect);
 }

 void SensorProvider::SetNewDevicesObserver() {
   DCHECK(sensor_service_remote_.is_bound());
   DCHECK(!new_devices_observer_.is_bound());
   if (current_state_.AllSensorsFound()) {
     // Don't need any further devices.
     return;
   }
   sensor_service_remote_->RegisterNewDevicesObserver(
       new_devices_observer_.BindNewPipeAndPassRemote());
   new_devices_observer_.set_disconnect_handler(
       base::BindOnce(&SensorProvider::OnNewDevicesObserverDisconnect,
                      weak_ptr_factory_.GetWeakPtr()));
 }

 void SensorProvider::OnNewDevicesObserverDisconnect() {
   LOG(ERROR)
       << "OnNewDevicesObserverDisconnect, resetting SensorService as IIO "
          "Service should be destructed and waiting for the relaunch of it.";
   ResetSensorService();
 }

 void SensorProvider::ResetSensorService() {
   new_devices_observer_.reset();
   sensor_service_remote_.reset();
   // Discard SensorData to prevent sensors removed while disconnected.
   ResetStates();
 }

 void SensorProvider::QueryDevices() {
   DCHECK(sensor_service_remote_.is_bound());
   // Get lid_angle sensors
   sensor_service_remote_->GetDeviceIds(
       DeviceType::ANGL, base::BindOnce(&SensorProvider::OnLidAngleIds,
                                        weak_ptr_factory_.GetWeakPtr()));
   // Get accelerometer sensors
   sensor_service_remote_->GetDeviceIds(
       DeviceType::ACCEL, base::BindOnce(&SensorProvider::OnAccelerometerIds,
                                         weak_ptr_factory_.GetWeakPtr()));
   // Get gyroscope sensors
   sensor_service_remote_->GetDeviceIds(
       DeviceType::ANGLVEL, base::BindOnce(&SensorProvider::OnGyroscopeIds,
                                           weak_ptr_factory_.GetWeakPtr()));
 }

 void SensorProvider::OnLidAngleIds(const std::vector<int32_t>& lid_angle_ids) {
   for (int32_t id : lid_angle_ids) {
     RegisterSensor(DeviceType::ANGL, id);
   }
 }

 void SensorProvider::OnAccelerometerIds(
     const std::vector<int32_t>& accelerometer_ids) {
   for (int32_t id : accelerometer_ids) {
     RegisterSensor(DeviceType::ACCEL, id);
   }
 }

 void SensorProvider::OnGyroscopeIds(const std::vector<int32_t>& gyroscope_ids) {
   for (int32_t id : gyroscope_ids) {
     RegisterSensor(DeviceType::ANGLVEL, id);
   }
 }

 void SensorProvider::RegisterSensor(DeviceType device_type, int32_t id) {
   auto& sensor = sensors_[id][device_type];

   if (sensor.ignored) {
     // Something went wrong in the previous initialization. Ignoring this
     // sensor.
     return;
   }

   if (sensor.remote.is_bound()) {
     // Has already been registered.
     return;
   }
   DCHECK(!sensor.samples_observer.get())
       << "Registering a sensor for device id " << id << " type " << device_type
       << "when there already exists one.";
   if (!sensor_service_remote_.is_bound()) {
     // Something went wrong. Skipping here.
     LOG(ERROR) << "SensorService is not initialized.";
     return;
   }

   sensor_service_remote_->GetDevice(id,
                                     sensor.remote.BindNewPipeAndPassReceiver());
   sensor.remote.set_disconnect_with_reason_handler(
       base::BindOnce(&SensorProvider::OnSensorRemoteDisconnect,
                      weak_ptr_factory_.GetWeakPtr(), device_type, id));
   if (device_type == DeviceType::ANGL) {
     // Samples from ANGL range from 0-180 (which means lid_angle degree), so set
     // scale to 1.
     // Location of lid_angle device is meaningless, so set to kOther.
     sensor.location = SensorLocation::kOther;
     sensor.scale = 1.0;
     if (base::Contains(type_to_sensor_id_, SensorType::kLidAngle)) {
       LOG(WARNING) << "Duplicated location source "
                    << "id_angle"
                    << " of sensor id: " << id << ", and sensor id: "
                    << type_to_sensor_id_[SensorType::kLidAngle];
       IgnoreSensor(device_type, id);
       return;
     }
     current_state_.AddSource(SensorType::kLidAngle);
     type_to_sensor_id_[SensorType::kLidAngle] = id;
   }
   std::vector<std::string> attr_names;
   if (!sensor.location.has_value()) {
     attr_names.push_back(chromeos::sensors::mojom::kLocation);
   }
   if (!sensor.scale.has_value()) {
     attr_names.push_back(chromeos::sensors::mojom::kScale);
   }
   if (attr_names.empty() || device_type == DeviceType::ANGL) {
     // Create the observer directly if the attributes have already been
     // retrieved. Won't create SamplesObserver for lid_angle sensor.
     CreateSensorSamplesObserver(device_type, id);

     return;
   }

   sensor.remote->GetAttributes(
       attr_names,
       base::BindOnce(&SensorProvider::OnAttributes,
                      weak_ptr_factory_.GetWeakPtr(), device_type, id));
 }

 void SensorProvider::OnSensorRemoteDisconnect(DeviceType device_type,
                                               int32_t id,
                                               uint32_t custom_reason_code,
                                               const std::string& description) {
   auto& sensor = sensors_[id][device_type];
   auto reason =
       static_cast<chromeos::sensors::mojom::SensorDeviceDisconnectReason>(
           custom_reason_code);
   LOG(WARNING) << "OnSensorRemoteDisconnect: " << id << ", reason: " << reason
                << ", description: " << description;

   switch (reason) {
     case chromeos::sensors::mojom::SensorDeviceDisconnectReason::
         IIOSERVICE_CRASHED:
       ResetSensorService();
       break;

     case chromeos::sensors::mojom::SensorDeviceDisconnectReason::DEVICE_REMOVED:
       // This sensor is not in use.
       if (sensor.ignored || !sensor.location.has_value() ||
           !sensor.scale.has_value()) {
         sensors_[id].erase(device_type);
       } else {
         // Reset usages & states, and restart the mojo devices initialization.
         ResetStates();
       }
       break;
   }
 }

 void SensorProvider::ResetStates() {
   current_state_.Reset();
   sensors_.clear();
   type_to_sensor_id_.clear();
   update_.Reset();
   if (sensor_service_remote_.is_bound()) {
     QueryDevices();
   }
 }

 void SensorProvider::IgnoreSensor(DeviceType device_type, int32_t id) {
   auto& sensor = sensors_[id][device_type];

   LOG(WARNING) << "Ignoring sensor with id: " << id
                << " device_type:" << device_type;

   sensor.ignored = true;
   sensor.remote.reset();
   sensor.samples_observer.reset();
 }

 void SensorProvider::EnableSensorReading() {
   sensor_read_on_ = true;
   EnableSensorReadingInternal();
 }

 void SensorProvider::EnableSensorReadingInternal() {
   // Starts Sensor Reading if all sensors are ready.
   if (sensor_read_on_ && CheckSensorSamplesObserver()) {
     GetLidAngleUpdate();
     for (auto& sensor : sensors_) {
       for (auto& type : sensor.second) {
         if (!type.second.samples_observer.get()) {
           continue;
         }
         type.second.samples_observer->SetEnabled(true);
       }
     }
   }
 }

 void SensorProvider::StopSensorReading() {
   for (auto& sensor : sensors_) {
     for (auto& type : sensor.second) {
       if (!type.second.samples_observer.get()) {
         continue;
       }
       type.second.samples_observer->SetEnabled(false);
     }
   }
   sensor_read_on_ = false;
 }

 void SensorProvider::CreateSensorSamplesObserver(DeviceType device_type,
                                                  int32_t id) {
   auto& sensor = sensors_[id][device_type];
   DCHECK(sensor.remote.is_bound());
   DCHECK(!sensor.ignored);
   DCHECK(sensor.scale.has_value() && sensor.location.has_value());
   if (device_type == DeviceType::ACCEL || device_type == DeviceType::ANGLVEL) {
     sensor.samples_observer = std::make_unique<AccelGyroSamplesObserver>(
         id, std::move(sensor.remote), sensor.scale.value(),
         base::BindRepeating(&SensorProvider::OnSampleUpdatedCallback,
                             weak_ptr_factory_.GetWeakPtr(), device_type),
         device_type, kReadFrequencyInHz);
   }
   EnableSensorReadingInternal();
 }

 bool SensorProvider::CheckSensorSamplesObserver() {
   for (auto& sensor_id : sensors_) {
     for (auto& [type, sensor_data] : sensor_id.second) {
       if (type == DeviceType::ANGL || sensor_data.ignored) {
         continue;
       }
       if (!sensor_data.samples_observer.get()) {
         return false;
       }
     }
   }
   return true;
 }

 void SensorProvider::OnAttributes(
     DeviceType device_type,
     int32_t id,
     const std::vector<std::optional<std::string>>& values) {
   auto& sensor = sensors_[id][device_type];
   DCHECK(sensor.remote.is_bound());
   auto val_it = values.begin();
   SensorType source;
   if (!sensor.location.has_value()) {
     if (val_it == values.end()) {
       LOG(ERROR) << "values doesn't contain location attribute.";
       IgnoreSensor(device_type, id);
       return;
     }

     if (!val_it->has_value()) {
       LOG(WARNING) << "No location attribute for sensor with id: " << id;
       IgnoreSensor(device_type, id);
       return;
     }

     auto* it = base::ranges::find(kLocationStrings, val_it->value());
     if (it == std::end(kLocationStrings)) {
       LOG(WARNING) << "Unrecognized location: " << val_it->value()
                    << " for device with id: " << id;
       IgnoreSensor(device_type, id);
       return;
     }

     SensorLocation location = static_cast<SensorLocation>(
         std::distance(std::begin(kLocationStrings), it));
     sensor.location = location;
     if (device_type == DeviceType::ACCEL) {
       if (location == SensorLocation::kBase) {
         source = SensorType::kAccelerometerBase;
       } else {
         source = SensorType::kAccelerometerLid;
       }
     } else {
       if (location == SensorLocation::kBase) {
         source = SensorType::kGyroscopeBase;
       } else {
         source = SensorType::kGyroscopeLid;
       }
     }
     if (base::Contains(type_to_sensor_id_, source)) {
       LOG(WARNING) << "Duplicated location source " << static_cast<int>(source)
                    << " of sensor id: " << id
                    << ", and sensor id: " << type_to_sensor_id_[source];
       IgnoreSensor(device_type, id);
       return;
     }
     val_it++;
   }

   if (!sensor.scale.has_value()) {
     if (val_it == values.end()) {
       LOG(ERROR) << "values doesn't contain scale attribute.";
       IgnoreSensor(device_type, id);
       return;
     }

     double scale = 0.0;
     if (!val_it->has_value() ||
         !base::StringToDouble(val_it->value(), &scale)) {
       LOG(ERROR) << "Invalid scale: " << val_it->value_or("")
                  << ", for accel with id: " << id;
       IgnoreSensor(device_type, id);
       return;
     }
     sensor.scale = scale;
   }

   DCHECK(!sensor.ignored);
   current_state_.AddSource(source);
   type_to_sensor_id_[source] = id;
   CreateSensorSamplesObserver(device_type, id);
 }

 void SensorProvider::GetLidAngleUpdate() {
   if (current_state_.GetSource(SensorType::kLidAngle) &&
       !update_.has(SensorType::kLidAngle)) {
     sensors_[type_to_sensor_id_[SensorType::kLidAngle]][DeviceType::ANGL]
         .remote->GetChannelsAttributes(
             {0}, {"raw"},
             base::BindRepeating(&SensorProvider::OnLidAngleValue,
                                 weak_ptr_factory_.GetWeakPtr()));
   }
 }

 void SensorProvider::OnSampleUpdatedCallback(DeviceType device_type,
                                              int iio_device_id,
                                              std::vector<float> sample) {
   DCHECK_EQ(sample.size(), kNumberOfAxes);
   SensorType key;
   bool find = false;
   for (auto& i : type_to_sensor_id_) {
     if (i.second == iio_device_id) {
       key = i.first;
       if ((key == SensorType::kAccelerometerBase ||
            key == SensorType::kAccelerometerLid) &&
           device_type == DeviceType::ACCEL) {
         find = true;
         break;
       } else if ((key == SensorType::kGyroscopeBase ||
                   key == SensorType::kGyroscopeLid) &&
                  device_type == DeviceType::ANGLVEL) {
         find = true;
         break;
       }
     }
   }
   if (!find) {
     LOG(ERROR) << "Couldn't find the the SensorType that matches DeviceType: "
                << device_type << " and device_id: " << iio_device_id;
     return;
   }

   update_.Set(key, sample[0], sample[1], sample[2]);

   if (!current_state_.CompareUpdate(update_)) {
     // Wait for other sensors to be updated.
     return;
   }

   NotifySensorUpdated(update_);
 }

 void SensorProvider::OnLidAngleValue(
     const std::vector<std::optional<std::string>>& values) {
   if (values[0].has_value()) {
     int angle;
     if (base::StringToInt(values[0].value(), &angle)) {
       update_.Set(SensorType::kLidAngle, angle);
       if (current_state_.CompareUpdate(update_)) {
         NotifySensorUpdated(update_);
       }
       return;
     }

     LOG(ERROR) << "Failed to convert lid angle sample into integer.";
   } else {
     LOG(ERROR) << "Lid Angle device couldn't get angle return.";
   }

   base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
       FROM_HERE,
       base::BindOnce(&SensorProvider::GetLidAngleUpdate,
                      weak_ptr_factory_.GetWeakPtr()),
       kLidAngleTimeout);
 }

 void SensorProvider::NotifySensorUpdated(SensorUpdate update) {
   for (auto& observer : observers_) {
     observer.OnSensorUpdated(update);
   }
   update_.Reset();

   GetLidAngleUpdate();
 }

 void SensorProvider::AddObserver(SensorObserver* observer) {
   observers_.AddObserver(observer);
 }

 void SensorProvider::RemoveObserver(SensorObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 }  // namespace ash
	// Copyright 2023 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "ash/sensor_info/sensor_provider.h"

	#include <cstddef>
	#include <iterator>
	#include <utility>

	#include "ash/sensor_info/sensor_types.h"
	#include "base/containers/contains.h"
	#include "base/functional/bind.h"
	#include "base/ranges/algorithm.h"
	#include "base/strings/string_number_conversions.h"
	#include "base/strings/string_util.h"
	#include "base/time/time.h"
	#include "chromeos/components/sensors/ash/sensor_hal_dispatcher.h"
	#include "chromeos/components/sensors/mojom/sensor.mojom.h"

	namespace ash {

	using ::chromeos::sensors::mojom::DeviceType;

	namespace {

	// Delay of the reconnection to Sensor Hal Dispatcher.
	constexpr base::TimeDelta kDelayReconnect = base::Seconds(1);

	// Timeout for getting lid_angle samples.
	constexpr base::TimeDelta kLidAngleTimeout = base::Seconds(1);

	constexpr double kReadFrequencyInHz = 100.0;

	} // namespace

	SensorProvider::DeviceState::DeviceState() {
	for (int index = 0; index < static_cast<int>(SensorType::kSensorTypeCount);
	++index) {
	present_.push_back(false);
	}
	}

	SensorProvider::DeviceState::~DeviceState() = default;

	bool SensorProvider::DeviceState::AllSensorsFound() const {
	for (int index = 0; index < static_cast<int>(SensorType::kSensorTypeCount);
	++index) {
	if (!present_[index]) {
	return false;
	}
	}
	return true;
	}

	void SensorProvider::DeviceState::Reset() {
	for (int index = 0; index < static_cast<int>(SensorType::kSensorTypeCount);
	++index) {
	present_[index] = false;
	}
	}

	bool SensorProvider::DeviceState::CompareUpdate(SensorUpdate update) const {
	for (int index = 0; index < static_cast<int>(SensorType::kSensorTypeCount);
	++index) {
	auto source = static_cast<SensorType>(index);
	if (!present_[index]) {
	if (update.has(source)) {
	LOG(ERROR) << "SensorUpdate has extra source: "
	<< static_cast<int>(source);
	}
	continue;
	}
	if (update.has(source)) {
	continue;
	}
	return false;
	}
	return true;
	}

	void SensorProvider::DeviceState::AddSource(SensorType source) {
	present_[static_cast<int>(source)] = true;
	}

	void SensorProvider::DeviceState::RemoveSource(SensorType source) {
	present_[static_cast<int>(source)] = false;
	}

	bool SensorProvider::DeviceState::GetSource(SensorType source) const {
	return present_[static_cast<int>(source)];
	}

	std::vector<bool> SensorProvider::DeviceState::GetStatesForTesting() const {
	return present_;
	}

	SensorProvider::SensorData::SensorData() = default;
	SensorProvider::SensorData::~SensorData() = default;

	SensorProvider::SensorProvider() {
	RegisterSensorClient();
	}

	SensorProvider::~SensorProvider() = default;

	void SensorProvider::SetUpChannel(
	mojo::PendingRemote<chromeos::sensors::mojom::SensorService>
	pending_remote) {
	if (sensor_service_remote_.is_bound()) {
	LOG(ERROR) << "Ignoring the second Remote<SensorService>";
	return;
	}

	sensor_service_remote_.Bind(std::move(pending_remote));
	sensor_service_remote_.set_disconnect_handler(
	base::BindOnce(&SensorProvider::OnSensorServiceDisconnect,
	weak_ptr_factory_.GetWeakPtr()));
	SetNewDevicesObserver();

	QueryDevices();
	}

	void SensorProvider::OnSensorServiceDisconnect() {
	LOG(ERROR) << "OnSensorServiceDisconnect";

	ResetSensorService();
	}

	std::vector<bool> SensorProvider::GetStateForTesting() {
	return current_state_.GetStatesForTesting(); // IN-TEST
	}

	void SensorProvider::OnNewDeviceAdded(int32_t iio_device_id,
	const std::vector<DeviceType>& types) {
	for (const auto& type : types) {
	if (type == DeviceType::ACCEL \|\| type == DeviceType::ANGL \|\|
	type == DeviceType::ANGLVEL) {
	RegisterSensor(type, iio_device_id);
	}
	}
	}

	void SensorProvider::RegisterSensorClient() {
	auto* dispatcher = chromeos::sensors::SensorHalDispatcher::GetInstance();
	if (!dispatcher) {
	// In unit tests, SensorHalDispatcher is not initialized.
	return;
	}

	dispatcher->RegisterClient(sensor_hal_client_.BindNewPipeAndPassRemote());

	sensor_hal_client_.set_disconnect_handler(
	base::BindOnce(&SensorProvider::OnSensorHalClientFailure,
	weak_ptr_factory_.GetWeakPtr()));
	}

	void SensorProvider::OnSensorHalClientFailure() {
	LOG(ERROR) << "OnSensorHalClientFailure";

	ResetSensorService();
	sensor_hal_client_.reset();
	// It's expected that SensorHalDispatcher will restart after failure,
	// so it's OK to retry forever here.
	base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
	FROM_HERE,
	base::BindOnce(&SensorProvider::RegisterSensorClient,
	weak_ptr_factory_.GetWeakPtr()),
	kDelayReconnect);
	}

	void SensorProvider::SetNewDevicesObserver() {
	DCHECK(sensor_service_remote_.is_bound());
	DCHECK(!new_devices_observer_.is_bound());
	if (current_state_.AllSensorsFound()) {
	// Don't need any further devices.
	return;
	}
	sensor_service_remote_->RegisterNewDevicesObserver(
	new_devices_observer_.BindNewPipeAndPassRemote());
	new_devices_observer_.set_disconnect_handler(
	base::BindOnce(&SensorProvider::OnNewDevicesObserverDisconnect,
	weak_ptr_factory_.GetWeakPtr()));
	}

	void SensorProvider::OnNewDevicesObserverDisconnect() {
	LOG(ERROR)
	<< "OnNewDevicesObserverDisconnect, resetting SensorService as IIO "
	"Service should be destructed and waiting for the relaunch of it.";
	ResetSensorService();
	}

	void SensorProvider::ResetSensorService() {
	new_devices_observer_.reset();
	sensor_service_remote_.reset();
	// Discard SensorData to prevent sensors removed while disconnected.
	ResetStates();
	}

	void SensorProvider::QueryDevices() {
	DCHECK(sensor_service_remote_.is_bound());
	// Get lid_angle sensors
	sensor_service_remote_->GetDeviceIds(
	DeviceType::ANGL, base::BindOnce(&SensorProvider::OnLidAngleIds,
	weak_ptr_factory_.GetWeakPtr()));
	// Get accelerometer sensors
	sensor_service_remote_->GetDeviceIds(
	DeviceType::ACCEL, base::BindOnce(&SensorProvider::OnAccelerometerIds,
	weak_ptr_factory_.GetWeakPtr()));
	// Get gyroscope sensors
	sensor_service_remote_->GetDeviceIds(
	DeviceType::ANGLVEL, base::BindOnce(&SensorProvider::OnGyroscopeIds,
	weak_ptr_factory_.GetWeakPtr()));
	}

	void SensorProvider::OnLidAngleIds(const std::vector<int32_t>& lid_angle_ids) {
	for (int32_t id : lid_angle_ids) {
	RegisterSensor(DeviceType::ANGL, id);
	}
	}

	void SensorProvider::OnAccelerometerIds(
	const std::vector<int32_t>& accelerometer_ids) {
	for (int32_t id : accelerometer_ids) {
	RegisterSensor(DeviceType::ACCEL, id);
	}
	}

	void SensorProvider::OnGyroscopeIds(const std::vector<int32_t>& gyroscope_ids) {
	for (int32_t id : gyroscope_ids) {
	RegisterSensor(DeviceType::ANGLVEL, id);
	}
	}

	void SensorProvider::RegisterSensor(DeviceType device_type, int32_t id) {
	auto& sensor = sensors_[id][device_type];

	if (sensor.ignored) {
	// Something went wrong in the previous initialization. Ignoring this
	// sensor.
	return;
	}

	if (sensor.remote.is_bound()) {
	// Has already been registered.
	return;
	}
	DCHECK(!sensor.samples_observer.get())
	<< "Registering a sensor for device id " << id << " type " << device_type
	<< "when there already exists one.";
	if (!sensor_service_remote_.is_bound()) {
	// Something went wrong. Skipping here.
	LOG(ERROR) << "SensorService is not initialized.";
	return;
	}

	sensor_service_remote_->GetDevice(id,
	sensor.remote.BindNewPipeAndPassReceiver());
	sensor.remote.set_disconnect_with_reason_handler(
	base::BindOnce(&SensorProvider::OnSensorRemoteDisconnect,
	weak_ptr_factory_.GetWeakPtr(), device_type, id));
	if (device_type == DeviceType::ANGL) {
	// Samples from ANGL range from 0-180 (which means lid_angle degree), so set
	// scale to 1.
	// Location of lid_angle device is meaningless, so set to kOther.
	sensor.location = SensorLocation::kOther;
	sensor.scale = 1.0;
	if (base::Contains(type_to_sensor_id_, SensorType::kLidAngle)) {
	LOG(WARNING) << "Duplicated location source "
	<< "id_angle"
	<< " of sensor id: " << id << ", and sensor id: "
	<< type_to_sensor_id_[SensorType::kLidAngle];
	IgnoreSensor(device_type, id);
	return;
	}
	current_state_.AddSource(SensorType::kLidAngle);
	type_to_sensor_id_[SensorType::kLidAngle] = id;
	}
	std::vector<std::string> attr_names;
	if (!sensor.location.has_value()) {
	attr_names.push_back(chromeos::sensors::mojom::kLocation);
	}
	if (!sensor.scale.has_value()) {
	attr_names.push_back(chromeos::sensors::mojom::kScale);
	}
	if (attr_names.empty() \|\| device_type == DeviceType::ANGL) {
	// Create the observer directly if the attributes have already been
	// retrieved. Won't create SamplesObserver for lid_angle sensor.
	CreateSensorSamplesObserver(device_type, id);

	return;
	}

	sensor.remote->GetAttributes(
	attr_names,
	base::BindOnce(&SensorProvider::OnAttributes,
	weak_ptr_factory_.GetWeakPtr(), device_type, id));
	}

	void SensorProvider::OnSensorRemoteDisconnect(DeviceType device_type,
	int32_t id,
	uint32_t custom_reason_code,
	const std::string& description) {
	auto& sensor = sensors_[id][device_type];
	auto reason =
	static_cast<chromeos::sensors::mojom::SensorDeviceDisconnectReason>(
	custom_reason_code);
	LOG(WARNING) << "OnSensorRemoteDisconnect: " << id << ", reason: " << reason
	<< ", description: " << description;

	switch (reason) {
	case chromeos::sensors::mojom::SensorDeviceDisconnectReason::
	IIOSERVICE_CRASHED:
	ResetSensorService();
	break;

	case chromeos::sensors::mojom::SensorDeviceDisconnectReason::DEVICE_REMOVED:
	// This sensor is not in use.
	if (sensor.ignored \|\| !sensor.location.has_value() \|\|
	!sensor.scale.has_value()) {
	sensors_[id].erase(device_type);
	} else {
	// Reset usages & states, and restart the mojo devices initialization.
	ResetStates();
	}
	break;
	}
	}

	void SensorProvider::ResetStates() {
	current_state_.Reset();
	sensors_.clear();
	type_to_sensor_id_.clear();
	update_.Reset();
	if (sensor_service_remote_.is_bound()) {
	QueryDevices();
	}
	}

	void SensorProvider::IgnoreSensor(DeviceType device_type, int32_t id) {
	auto& sensor = sensors_[id][device_type];

	LOG(WARNING) << "Ignoring sensor with id: " << id
	<< " device_type:" << device_type;

	sensor.ignored = true;
	sensor.remote.reset();
	sensor.samples_observer.reset();
	}

	void SensorProvider::EnableSensorReading() {
	sensor_read_on_ = true;
	EnableSensorReadingInternal();
	}

	void SensorProvider::EnableSensorReadingInternal() {
	// Starts Sensor Reading if all sensors are ready.
	if (sensor_read_on_ && CheckSensorSamplesObserver()) {
	GetLidAngleUpdate();
	for (auto& sensor : sensors_) {
	for (auto& type : sensor.second) {
	if (!type.second.samples_observer.get()) {
	continue;
	}
	type.second.samples_observer->SetEnabled(true);
	}
	}
	}
	}

	void SensorProvider::StopSensorReading() {
	for (auto& sensor : sensors_) {
	for (auto& type : sensor.second) {
	if (!type.second.samples_observer.get()) {
	continue;
	}
	type.second.samples_observer->SetEnabled(false);
	}
	}
	sensor_read_on_ = false;
	}

	void SensorProvider::CreateSensorSamplesObserver(DeviceType device_type,
	int32_t id) {
	auto& sensor = sensors_[id][device_type];
	DCHECK(sensor.remote.is_bound());
	DCHECK(!sensor.ignored);
	DCHECK(sensor.scale.has_value() && sensor.location.has_value());
	if (device_type == DeviceType::ACCEL \|\| device_type == DeviceType::ANGLVEL) {
	sensor.samples_observer = std::make_unique<AccelGyroSamplesObserver>(
	id, std::move(sensor.remote), sensor.scale.value(),
	base::BindRepeating(&SensorProvider::OnSampleUpdatedCallback,
	weak_ptr_factory_.GetWeakPtr(), device_type),
	device_type, kReadFrequencyInHz);
	}
	EnableSensorReadingInternal();
	}

	bool SensorProvider::CheckSensorSamplesObserver() {
	for (auto& sensor_id : sensors_) {
	for (auto& [type, sensor_data] : sensor_id.second) {
	if (type == DeviceType::ANGL \|\| sensor_data.ignored) {
	continue;
	}
	if (!sensor_data.samples_observer.get()) {
	return false;
	}
	}
	}
	return true;
	}

	void SensorProvider::OnAttributes(
	DeviceType device_type,
	int32_t id,
	const std::vector<std::optional<std::string>>& values) {
	auto& sensor = sensors_[id][device_type];
	DCHECK(sensor.remote.is_bound());
	auto val_it = values.begin();
	SensorType source;
	if (!sensor.location.has_value()) {
	if (val_it == values.end()) {
	LOG(ERROR) << "values doesn't contain location attribute.";
	IgnoreSensor(device_type, id);
	return;
	}

	if (!val_it->has_value()) {
	LOG(WARNING) << "No location attribute for sensor with id: " << id;
	IgnoreSensor(device_type, id);
	return;
	}

	auto* it = base::ranges::find(kLocationStrings, val_it->value());
	if (it == std::end(kLocationStrings)) {
	LOG(WARNING) << "Unrecognized location: " << val_it->value()
	<< " for device with id: " << id;
	IgnoreSensor(device_type, id);
	return;
	}

	SensorLocation location = static_cast<SensorLocation>(
	std::distance(std::begin(kLocationStrings), it));
	sensor.location = location;
	if (device_type == DeviceType::ACCEL) {
	if (location == SensorLocation::kBase) {
	source = SensorType::kAccelerometerBase;
	} else {
	source = SensorType::kAccelerometerLid;
	}
	} else {
	if (location == SensorLocation::kBase) {
	source = SensorType::kGyroscopeBase;
	} else {
	source = SensorType::kGyroscopeLid;
	}
	}
	if (base::Contains(type_to_sensor_id_, source)) {
	LOG(WARNING) << "Duplicated location source " << static_cast<int>(source)
	<< " of sensor id: " << id
	<< ", and sensor id: " << type_to_sensor_id_[source];
	IgnoreSensor(device_type, id);
	return;
	}
	val_it++;
	}

	if (!sensor.scale.has_value()) {
	if (val_it == values.end()) {
	LOG(ERROR) << "values doesn't contain scale attribute.";
	IgnoreSensor(device_type, id);
	return;
	}

	double scale = 0.0;
	if (!val_it->has_value() \|\|
	!base::StringToDouble(val_it->value(), &scale)) {
	LOG(ERROR) << "Invalid scale: " << val_it->value_or("")
	<< ", for accel with id: " << id;
	IgnoreSensor(device_type, id);
	return;
	}
	sensor.scale = scale;
	}

	DCHECK(!sensor.ignored);
	current_state_.AddSource(source);
	type_to_sensor_id_[source] = id;
	CreateSensorSamplesObserver(device_type, id);
	}

	void SensorProvider::GetLidAngleUpdate() {
	if (current_state_.GetSource(SensorType::kLidAngle) &&
	!update_.has(SensorType::kLidAngle)) {
	sensors_[type_to_sensor_id_[SensorType::kLidAngle]][DeviceType::ANGL]
	.remote->GetChannelsAttributes(
	{0}, {"raw"},
	base::BindRepeating(&SensorProvider::OnLidAngleValue,
	weak_ptr_factory_.GetWeakPtr()));
	}
	}

	void SensorProvider::OnSampleUpdatedCallback(DeviceType device_type,
	int iio_device_id,
	std::vector<float> sample) {
	DCHECK_EQ(sample.size(), kNumberOfAxes);
	SensorType key;
	bool find = false;
	for (auto& i : type_to_sensor_id_) {
	if (i.second == iio_device_id) {
	key = i.first;
	if ((key == SensorType::kAccelerometerBase \|\|
	key == SensorType::kAccelerometerLid) &&
	device_type == DeviceType::ACCEL) {
	find = true;
	break;
	} else if ((key == SensorType::kGyroscopeBase \|\|
	key == SensorType::kGyroscopeLid) &&
	device_type == DeviceType::ANGLVEL) {
	find = true;
	break;
	}
	}
	}
	if (!find) {
	LOG(ERROR) << "Couldn't find the the SensorType that matches DeviceType: "
	<< device_type << " and device_id: " << iio_device_id;
	return;
	}

	update_.Set(key, sample[0], sample[1], sample[2]);

	if (!current_state_.CompareUpdate(update_)) {
	// Wait for other sensors to be updated.
	return;
	}

	NotifySensorUpdated(update_);
	}

	void SensorProvider::OnLidAngleValue(
	const std::vector<std::optional<std::string>>& values) {
	if (values[0].has_value()) {
	int angle;
	if (base::StringToInt(values[0].value(), &angle)) {
	update_.Set(SensorType::kLidAngle, angle);
	if (current_state_.CompareUpdate(update_)) {
	NotifySensorUpdated(update_);
	}
	return;
	}

	LOG(ERROR) << "Failed to convert lid angle sample into integer.";
	} else {
	LOG(ERROR) << "Lid Angle device couldn't get angle return.";
	}

	base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
	FROM_HERE,
	base::BindOnce(&SensorProvider::GetLidAngleUpdate,
	weak_ptr_factory_.GetWeakPtr()),
	kLidAngleTimeout);
	}

	void SensorProvider::NotifySensorUpdated(SensorUpdate update) {
	for (auto& observer : observers_) {
	observer.OnSensorUpdated(update);
	}
	update_.Reset();

	GetLidAngleUpdate();
	}

	void SensorProvider::AddObserver(SensorObserver* observer) {
	observers_.AddObserver(observer);
	}

	void SensorProvider::RemoveObserver(SensorObserver* observer) {
	observers_.RemoveObserver(observer);
	}
	} // namespace ash