| // Copyright 2016 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "modules/sensor/SensorProxy.h" |
| |
| #include "core/frame/LocalFrame.h" |
| #include "modules/sensor/SensorProviderProxy.h" |
| #include "platform/mojo/MojoHelper.h" |
| |
| using namespace device::mojom::blink; |
| |
| namespace blink { |
| |
| SensorProxy::SensorProxy(SensorType sensorType, SensorProviderProxy* provider) |
| : m_type(sensorType) |
| , m_mode(ReportingMode::CONTINUOUS) |
| , m_provider(provider) |
| , m_clientBinding(this) |
| , m_state(SensorProxy::Uninitialized) |
| , m_reading() |
| , m_suspended(false) |
| { |
| } |
| |
| SensorProxy::~SensorProxy() |
| { |
| } |
| |
| void SensorProxy::dispose() |
| { |
| m_clientBinding.Close(); |
| } |
| |
| DEFINE_TRACE(SensorProxy) |
| { |
| visitor->trace(m_observers); |
| visitor->trace(m_provider); |
| } |
| |
| void SensorProxy::addObserver(Observer* observer) |
| { |
| if (!m_observers.contains(observer)) |
| m_observers.add(observer); |
| } |
| |
| void SensorProxy::removeObserver(Observer* observer) |
| { |
| m_observers.remove(observer); |
| } |
| |
| void SensorProxy::initialize() |
| { |
| if (m_state != Uninitialized) |
| return; |
| |
| if (!m_provider->sensorProvider()) { |
| handleSensorError(); |
| return; |
| } |
| |
| m_state = Initializing; |
| auto callback = convertToBaseCallback(WTF::bind(&SensorProxy::onSensorCreated, wrapWeakPersistent(this))); |
| m_provider->sensorProvider()->GetSensor(m_type, mojo::GetProxy(&m_sensor), callback); |
| m_sensor.set_connection_error_handler(convertToBaseCallback(WTF::bind(&SensorProxy::handleSensorError, wrapWeakPersistent(this)))); |
| } |
| |
| void SensorProxy::addConfiguration(SensorConfigurationPtr configuration, std::unique_ptr<Function<void(bool)>> callback) |
| { |
| DCHECK(isInitialized()); |
| m_sensor->AddConfiguration(std::move(configuration), convertToBaseCallback(std::move(callback))); |
| } |
| |
| void SensorProxy::removeConfiguration(SensorConfigurationPtr configuration, std::unique_ptr<Function<void(bool)>> callback) |
| { |
| DCHECK(isInitialized()); |
| m_sensor->RemoveConfiguration(std::move(configuration), convertToBaseCallback(std::move(callback))); |
| } |
| |
| void SensorProxy::suspend() |
| { |
| DCHECK(isInitialized()); |
| if (m_suspended) |
| return; |
| |
| m_sensor->Suspend(); |
| m_suspended = true; |
| } |
| |
| void SensorProxy::resume() |
| { |
| DCHECK(isInitialized()); |
| if (!m_suspended) |
| return; |
| |
| m_sensor->Resume(); |
| m_suspended = false; |
| } |
| |
| const device::mojom::blink::SensorConfiguration* SensorProxy::defaultConfig() const |
| { |
| DCHECK(isInitialized()); |
| return m_defaultConfig.get(); |
| } |
| |
| void SensorProxy::updateInternalReading() |
| { |
| DCHECK(isInitialized()); |
| Reading* reading = static_cast<Reading*>(m_sharedBuffer.get()); |
| m_reading = *reading; |
| } |
| |
| void SensorProxy::RaiseError() |
| { |
| handleSensorError(); |
| } |
| |
| void SensorProxy::SensorReadingChanged() |
| { |
| for (Observer* observer : m_observers) |
| observer->onSensorReadingChanged(); |
| } |
| |
| void SensorProxy::handleSensorError() |
| { |
| m_state = Uninitialized; |
| m_sensor.reset(); |
| m_sharedBuffer.reset(); |
| m_sharedBufferHandle.reset(); |
| m_defaultConfig.reset(); |
| m_clientBinding.Close(); |
| |
| for (Observer* observer : m_observers) |
| observer->onSensorError(); |
| } |
| |
| void SensorProxy::onSensorCreated(SensorInitParamsPtr params, SensorClientRequest clientRequest) |
| { |
| DCHECK_EQ(Initializing, m_state); |
| if (!params) { |
| handleSensorError(); |
| return; |
| } |
| |
| DCHECK_EQ(0u, params->buffer_offset % SensorInitParams::kReadBufferSize); |
| |
| m_mode = params->mode; |
| m_defaultConfig = std::move(params->default_configuration); |
| if (!m_defaultConfig) { |
| handleSensorError(); |
| return; |
| } |
| |
| DCHECK(m_sensor.is_bound()); |
| m_clientBinding.Bind(std::move(clientRequest)); |
| |
| m_sharedBufferHandle = std::move(params->memory); |
| DCHECK(!m_sharedBuffer); |
| m_sharedBuffer = m_sharedBufferHandle->MapAtOffset(SensorInitParams::kReadBufferSize, params->buffer_offset); |
| |
| if (!m_sharedBuffer) { |
| handleSensorError(); |
| return; |
| } |
| |
| m_state = Initialized; |
| for (Observer* observer : m_observers) |
| observer->onSensorInitialized(); |
| } |
| |
| } // namespace blink |