OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "modules/sensor/Sensor.h" | 5 #include "modules/sensor/Sensor.h" |
6 | 6 |
7 #include "core/dom/Document.h" | 7 #include "core/dom/Document.h" |
8 #include "core/dom/ExceptionCode.h" | 8 #include "core/dom/ExceptionCode.h" |
9 #include "core/dom/ExecutionContextTask.h" | 9 #include "device/generic_sensor/public/interfaces/sensor.mojom-blink.h" |
10 #include "core/events/Event.h" | 10 #include "modules/sensor/SensorErrorEvent.h" |
11 | 11 #include "modules/sensor/SensorPollingStrategy.h" |
| 12 #include "modules/sensor/SensorProviderProxy.h" |
12 #include "modules/sensor/SensorReading.h" | 13 #include "modules/sensor/SensorReading.h" |
| 14 #include "modules/sensor/SensorReadingEvent.h" |
| 15 |
| 16 using namespace device::mojom::blink; |
13 | 17 |
14 namespace blink { | 18 namespace blink { |
15 | 19 |
16 Sensor::~Sensor() | 20 Sensor::Sensor(ExecutionContext* executionContext, const SensorOptions& sensorOp
tions, SensorType type) |
17 { | |
18 } | |
19 | |
20 Sensor::Sensor(ExecutionContext* executionContext, const SensorOptions& sensorOp
tions) | |
21 : ActiveScriptWrappable(this) | 21 : ActiveScriptWrappable(this) |
22 , ActiveDOMObject(executionContext) | 22 , ActiveDOMObject(executionContext) |
23 , PlatformEventController(toDocument(executionContext)->page()) | 23 , PageVisibilityObserver(toDocument(executionContext)->page()) |
24 , m_sensorState(SensorState::Idle) | |
25 , m_sensorReading(nullptr) | |
26 , m_sensorOptions(sensorOptions) | 24 , m_sensorOptions(sensorOptions) |
27 { | 25 , m_type(type) |
| 26 , m_state(Sensor::SensorState::IDLE) |
| 27 , m_storedData() |
| 28 { |
| 29 DCHECK(executionContext->isDocument()); |
| 30 } |
| 31 |
| 32 void Sensor::dispose() |
| 33 { |
| 34 stopListening(); |
| 35 } |
| 36 |
| 37 void Sensor::start(ScriptState* scriptState, ExceptionState& exceptionState) |
| 38 { |
| 39 if (m_state != Sensor::SensorState::IDLE && m_state != Sensor::SensorState::
ERRORED) { |
| 40 exceptionState.throwDOMException(InvalidStateError, "Cannot start becaus
e SensorState is not idle or errored"); |
| 41 return; |
| 42 } |
| 43 |
| 44 initSensorProxyIfNeeded(); |
| 45 |
| 46 if (!m_sensorProxy) { |
| 47 exceptionState.throwDOMException(InvalidStateError, "The Sensor is no lo
nger associated to a frame."); |
| 48 return; |
| 49 } |
| 50 |
| 51 updateState(Sensor::SensorState::ACTIVATING); |
| 52 |
| 53 startListening(); |
| 54 } |
| 55 |
| 56 void Sensor::stop(ScriptState*, ExceptionState& exceptionState) |
| 57 { |
| 58 if (m_state == Sensor::SensorState::IDLE || m_state == Sensor::SensorState::
ERRORED) { |
| 59 exceptionState.throwDOMException(InvalidStateError, "Cannot stop because
SensorState is either idle or errored"); |
| 60 return; |
| 61 } |
| 62 |
| 63 if (!m_sensorProxy) { |
| 64 exceptionState.throwDOMException(InvalidStateError, "The Sensor is no lo
nger associated to a frame."); |
| 65 return; |
| 66 } |
| 67 |
| 68 stopListening(); |
| 69 } |
| 70 |
| 71 static String ToString(Sensor::SensorState state) |
| 72 { |
| 73 switch (state) { |
| 74 case Sensor::SensorState::IDLE: |
| 75 return "idle"; |
| 76 case Sensor::SensorState::ACTIVATING: |
| 77 return "activating"; |
| 78 case Sensor::SensorState::ACTIVE: |
| 79 return "active"; |
| 80 case Sensor::SensorState::ERRORED: |
| 81 return "errored"; |
| 82 default: |
| 83 NOTREACHED(); |
| 84 } |
| 85 return "idle"; |
28 } | 86 } |
29 | 87 |
30 // Getters | 88 // Getters |
31 String Sensor::state() const | 89 String Sensor::state() const |
32 { | 90 { |
33 // TODO(riju): Validate the transitions. | 91 return ToString(m_state); |
34 switch (m_sensorState) { | |
35 case SensorState::Idle: | |
36 return "idle"; | |
37 case SensorState::Activating: | |
38 return "activating"; | |
39 case SensorState::Active: | |
40 return "active"; | |
41 case SensorState::Errored: | |
42 return "errored"; | |
43 } | |
44 NOTREACHED(); | |
45 return "idle"; | |
46 } | 92 } |
47 | 93 |
48 SensorReading* Sensor::reading() const | 94 SensorReading* Sensor::reading() const |
49 { | 95 { |
50 return m_sensorReading.get(); | 96 return m_sensorReading.get(); |
51 } | 97 } |
52 | 98 |
53 void Sensor::start(ScriptState* scriptState, ExceptionState& exceptionState) | 99 DEFINE_TRACE(Sensor) |
54 { | 100 { |
55 | 101 visitor->trace(m_polling); |
56 if (m_sensorState != SensorState::Idle && m_sensorState != SensorState::Erro
red) { | 102 visitor->trace(m_sensorProxy); |
57 exceptionState.throwDOMException(InvalidStateError, "Invalid State: Sens
orState is not idle or errored"); | 103 visitor->trace(m_sensorReading); |
58 return; | 104 ActiveScriptWrappable::trace(visitor); |
59 } | 105 ActiveDOMObject::trace(visitor); |
60 | 106 PageVisibilityObserver::trace(visitor); |
61 updateState(SensorState::Activating); | 107 EventTargetWithInlineData::trace(visitor); |
62 | 108 } |
63 // TODO(riju) : Add Permissions stuff later. | 109 |
64 | 110 bool Sensor::hasPendingActivity() const |
65 m_hasEventListener = true; | 111 { |
66 | 112 if (!getExecutionContext() || getExecutionContext()->activeDOMObjectsAreStop
ped()) |
67 // TODO(riju): verify the correct order of onstatechange(active) and the fir
st onchange(event). | 113 return false; |
68 startUpdating(); | 114 return hasEventListeners(); |
69 } | 115 } |
70 | 116 |
71 void Sensor::stop(ScriptState* scriptState, ExceptionState& exceptionState) | 117 void Sensor::initSensorProxyIfNeeded() |
72 { | 118 { |
73 if (m_sensorState == SensorState::Idle || m_sensorState == SensorState::Erro
red) { | 119 if (m_sensorProxy) |
74 exceptionState.throwDOMException(InvalidStateError, "Invalid State: Sens
orState is either idle or errored"); | 120 return; |
75 return; | 121 |
76 } | 122 Document* document = toDocument(getExecutionContext()); |
77 | 123 if (!document->frame()) |
78 m_hasEventListener = false; | 124 return; |
79 stopUpdating(); | 125 |
80 | 126 m_sensorProxy = SensorProviderProxy::getOrCreateForFrame(document->frame())-
>getOrCreateSensor(m_type); |
81 m_sensorReading.clear(); | 127 } |
82 updateState(SensorState::Idle); | 128 |
83 } | 129 void Sensor::stop() |
84 | 130 { |
85 void Sensor::updateState(SensorState newState) | 131 stopListening(); |
86 { | 132 } |
87 DCHECK(isMainThread()); | 133 |
88 if (m_sensorState == newState) | 134 void Sensor::onSensorInitialized() |
89 return; | 135 { |
90 | 136 if (m_state != Sensor::SensorState::ACTIVATING) |
91 m_sensorState = newState; | 137 return; |
92 // Notify context that state changed. | 138 |
93 if (getExecutionContext()) | 139 if (!m_sensorProxy) { |
94 getExecutionContext()->postTask(BLINK_FROM_HERE, createSameThreadTask(&S
ensor::notifyStateChange, wrapPersistent(this))); | 140 reportError(); |
95 } | 141 return; |
96 | 142 } |
97 void Sensor::notifyStateChange() | 143 |
98 { | 144 m_configuration = createSensorConfig(m_sensorOptions, m_sensorProxy->default
Configuration()); |
| 145 if (!m_configuration) { |
| 146 reportError(); |
| 147 return; |
| 148 } |
| 149 |
| 150 auto startCallback = WTF::bind(&Sensor::onStartRequestCompleted, wrapWeakPer
sistent(this)); |
| 151 m_sensorProxy->addConfiguration(m_configuration->Clone(), std::move(startCal
lback)); |
| 152 } |
| 153 |
| 154 void Sensor::onSensorReadingChanged() |
| 155 { |
| 156 if (m_polling) |
| 157 m_polling->onSensorReadingChanged(); |
| 158 } |
| 159 |
| 160 void Sensor::onSensorError() |
| 161 { |
| 162 reportError(); |
| 163 } |
| 164 |
| 165 void Sensor::onStartRequestCompleted(bool result) |
| 166 { |
| 167 if (m_state != Sensor::SensorState::ACTIVATING) |
| 168 return; |
| 169 |
| 170 if (!result || !m_sensorProxy) { |
| 171 reportError(); |
| 172 return; |
| 173 } |
| 174 |
| 175 updateState(Sensor::SensorState::ACTIVE); |
| 176 |
| 177 DCHECK(m_configuration); |
| 178 auto pollCallback = WTF::bind(&Sensor::pollForData, wrapWeakPersistent(this)
); |
| 179 m_polling = SensorPollingStrategy::create(m_configuration->frequency, std::m
ove(pollCallback), m_sensorProxy->reportingMode()); |
| 180 updatePollingStatus(); |
| 181 } |
| 182 |
| 183 void Sensor::onStopRequestCompleted(bool result) |
| 184 { |
| 185 if (m_state == Sensor::SensorState::IDLE) |
| 186 return; |
| 187 |
| 188 if (!result) |
| 189 reportError(); |
| 190 |
| 191 if (m_sensorProxy) |
| 192 m_sensorProxy->removeObserver(this); |
| 193 } |
| 194 |
| 195 void Sensor::pageVisibilityChanged() |
| 196 { |
| 197 updatePollingStatus(); |
| 198 } |
| 199 |
| 200 void Sensor::startListening() |
| 201 { |
| 202 if (!m_sensorProxy) |
| 203 return; |
| 204 |
| 205 if (!m_sensorReading) { |
| 206 m_sensorReading = createSensorReading(getExecutionContext()); |
| 207 m_sensorReading->attach(m_sensorProxy); |
| 208 } |
| 209 |
| 210 m_sensorProxy->addObserver(this); |
| 211 if (m_sensorProxy->isInitialized()) { |
| 212 auto callback = WTF::bind(&Sensor::onStartRequestCompleted, wrapWeakPers
istent(this)); |
| 213 DCHECK(m_configuration); |
| 214 m_sensorProxy->addConfiguration(m_configuration->Clone(), std::move(call
back)); |
| 215 } else { |
| 216 m_sensorProxy->initialize(); |
| 217 } |
| 218 } |
| 219 |
| 220 void Sensor::stopListening() |
| 221 { |
| 222 if (m_sensorReading) { |
| 223 m_sensorReading->detach(); |
| 224 m_sensorReading = nullptr; |
| 225 } |
| 226 |
| 227 updateState(Sensor::SensorState::IDLE); |
| 228 |
| 229 if (!m_sensorProxy) |
| 230 return; |
| 231 |
| 232 if (m_sensorProxy->isInitialized()) { |
| 233 auto callback = WTF::bind(&Sensor::onStopRequestCompleted, wrapWeakPersi
stent(this)); |
| 234 DCHECK(m_configuration); |
| 235 m_sensorProxy->removeConfiguration(m_configuration->Clone(), std::move(c
allback)); |
| 236 } else { |
| 237 m_sensorProxy->removeObserver(this); |
| 238 } |
| 239 } |
| 240 |
| 241 void Sensor::pollForData() |
| 242 { |
| 243 if (m_state != Sensor::SensorState::ACTIVE) { |
| 244 DCHECK(m_polling); |
| 245 m_polling->stopPolling(); |
| 246 return; |
| 247 } |
| 248 |
| 249 DCHECK(m_sensorProxy); |
| 250 m_sensorProxy->updateReading(); |
| 251 |
| 252 DCHECK(m_sensorReading); |
| 253 if (m_sensorReading->isReadingUpdated(m_storedData)) |
| 254 dispatchEvent(SensorReadingEvent::create(EventTypeNames::change, m_senso
rReading)); |
| 255 |
| 256 m_storedData = m_sensorProxy->reading(); |
| 257 } |
| 258 |
| 259 void Sensor::updateState(Sensor::SensorState newState) |
| 260 { |
| 261 if (newState == m_state) |
| 262 return; |
| 263 m_state = newState; |
99 dispatchEvent(Event::create(EventTypeNames::statechange)); | 264 dispatchEvent(Event::create(EventTypeNames::statechange)); |
100 } | 265 updatePollingStatus(); |
101 | 266 } |
102 void Sensor::suspend() | 267 |
103 { | 268 void Sensor::reportError() |
104 m_hasEventListener = false; | 269 { |
105 stopUpdating(); | 270 updateState(Sensor::SensorState::ERRORED); |
106 } | 271 // TODO(Mikhail) : Dispatch Sensor Error event. |
107 | 272 } |
108 void Sensor::resume() | 273 |
109 { | 274 void Sensor::updatePollingStatus() |
110 m_hasEventListener = true; | 275 { |
111 startUpdating(); | 276 if (!m_polling) |
112 } | 277 return; |
113 | 278 |
114 void Sensor::stop() | 279 if (m_state != Sensor::SensorState::ACTIVE |
115 { | 280 || page()->visibilityState() != PageVisibilityStateVisible) { |
116 m_hasEventListener = false; | 281 m_polling->stopPolling(); |
117 stopUpdating(); | 282 } else { |
118 } | 283 m_polling->startPolling(); |
119 | 284 } |
120 bool Sensor::hasPendingActivity() const | |
121 { | |
122 // Prevent V8 from garbage collecting the wrapper object if there are | |
123 // event listeners attached to it. | |
124 return hasEventListeners(); | |
125 } | |
126 | |
127 DEFINE_TRACE(Sensor) | |
128 { | |
129 ActiveDOMObject::trace(visitor); | |
130 EventTargetWithInlineData::trace(visitor); | |
131 PlatformEventController::trace(visitor); | |
132 visitor->trace(m_sensorReading); | |
133 } | 285 } |
134 | 286 |
135 } // namespace blink | 287 } // namespace blink |
OLD | NEW |