OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 "content/browser/device_sensors/data_fetcher_shared_memory.h" | 5 #include "device/device_sensors/data_fetcher_shared_memory.h" |
6 | 6 |
7 #include <GuidDef.h> | 7 #include <GuidDef.h> |
8 #include <InitGuid.h> | 8 #include <InitGuid.h> |
9 #include <PortableDeviceTypes.h> | 9 #include <PortableDeviceTypes.h> |
10 #include <Sensors.h> | 10 #include <Sensors.h> |
11 | 11 |
12 #include "base/logging.h" | 12 #include "base/logging.h" |
13 #include "base/metrics/histogram.h" | 13 #include "base/metrics/histogram.h" |
14 #include "base/win/iunknown_impl.h" | 14 #include "base/win/iunknown_impl.h" |
15 #include "base/win/windows_version.h" | 15 #include "base/win/windows_version.h" |
16 | 16 |
17 namespace { | 17 namespace { |
18 | 18 |
19 const double kMeanGravity = 9.80665; | 19 const double kMeanGravity = 9.80665; |
20 | 20 |
21 void SetLightBuffer(content::DeviceLightHardwareBuffer* buffer, double lux) { | 21 void SetLightBuffer(content::DeviceLightHardwareBuffer* buffer, double lux) { |
22 DCHECK(buffer); | 22 DCHECK(buffer); |
23 buffer->seqlock.WriteBegin(); | 23 buffer->seqlock.WriteBegin(); |
24 buffer->data.value = lux; | 24 buffer->data.value = lux; |
25 buffer->seqlock.WriteEnd(); | 25 buffer->seqlock.WriteEnd(); |
26 } | 26 } |
27 | 27 |
28 } // namespace | 28 } // namespace |
29 | 29 |
30 | |
31 namespace content { | 30 namespace content { |
32 | 31 |
33 class DataFetcherSharedMemory::SensorEventSink | 32 class DataFetcherSharedMemory::SensorEventSink |
34 : public ISensorEvents, public base::win::IUnknownImpl { | 33 : public ISensorEvents, |
| 34 public base::win::IUnknownImpl { |
35 public: | 35 public: |
36 SensorEventSink() {} | 36 SensorEventSink() {} |
37 ~SensorEventSink() override {} | 37 ~SensorEventSink() override {} |
38 | 38 |
39 // IUnknown interface | 39 // IUnknown interface |
40 ULONG STDMETHODCALLTYPE AddRef() override { | 40 ULONG STDMETHODCALLTYPE AddRef() override { return IUnknownImpl::AddRef(); } |
41 return IUnknownImpl::AddRef(); | |
42 } | |
43 | 41 |
44 ULONG STDMETHODCALLTYPE Release() override { | 42 ULONG STDMETHODCALLTYPE Release() override { return IUnknownImpl::Release(); } |
45 return IUnknownImpl::Release(); | |
46 } | |
47 | 43 |
48 STDMETHODIMP QueryInterface(REFIID riid, void** ppv) override { | 44 STDMETHODIMP QueryInterface(REFIID riid, void** ppv) override { |
49 if (riid == __uuidof(ISensorEvents)) { | 45 if (riid == __uuidof(ISensorEvents)) { |
50 *ppv = static_cast<ISensorEvents*>(this); | 46 *ppv = static_cast<ISensorEvents*>(this); |
51 AddRef(); | 47 AddRef(); |
52 return S_OK; | 48 return S_OK; |
53 } | 49 } |
54 return IUnknownImpl::QueryInterface(riid, ppv); | 50 return IUnknownImpl::QueryInterface(riid, ppv); |
55 } | 51 } |
56 | 52 |
57 // ISensorEvents interface | 53 // ISensorEvents interface |
58 STDMETHODIMP OnEvent(ISensor* sensor, | 54 STDMETHODIMP OnEvent(ISensor* sensor, |
59 REFGUID event_id, | 55 REFGUID event_id, |
60 IPortableDeviceValues* event_data) override { | 56 IPortableDeviceValues* event_data) override { |
61 return S_OK; | 57 return S_OK; |
62 } | 58 } |
63 | 59 |
64 STDMETHODIMP OnLeave(REFSENSOR_ID sensor_id) override { | 60 STDMETHODIMP OnLeave(REFSENSOR_ID sensor_id) override { return S_OK; } |
65 return S_OK; | |
66 } | |
67 | 61 |
68 STDMETHODIMP OnStateChanged(ISensor* sensor, SensorState state) override { | 62 STDMETHODIMP OnStateChanged(ISensor* sensor, SensorState state) override { |
69 return S_OK; | 63 return S_OK; |
70 } | 64 } |
71 | 65 |
72 STDMETHODIMP OnDataUpdated(ISensor* sensor, | 66 STDMETHODIMP OnDataUpdated(ISensor* sensor, |
73 ISensorDataReport* new_data) override { | 67 ISensorDataReport* new_data) override { |
74 if (nullptr == new_data || nullptr == sensor) | 68 if (nullptr == new_data || nullptr == sensor) |
75 return E_INVALIDARG; | 69 return E_INVALIDARG; |
76 return UpdateSharedMemoryBuffer(sensor, new_data) ? S_OK : E_FAIL; | 70 return UpdateSharedMemoryBuffer(sensor, new_data) ? S_OK : E_FAIL; |
77 } | 71 } |
78 | 72 |
79 protected: | 73 protected: |
80 virtual bool UpdateSharedMemoryBuffer( | 74 virtual bool UpdateSharedMemoryBuffer(ISensor* sensor, |
81 ISensor* sensor, ISensorDataReport* new_data) = 0; | 75 ISensorDataReport* new_data) = 0; |
82 | 76 |
83 void GetSensorValue(REFPROPERTYKEY property, ISensorDataReport* new_data, | 77 void GetSensorValue(REFPROPERTYKEY property, |
84 double* value, bool* has_value) { | 78 ISensorDataReport* new_data, |
| 79 double* value, |
| 80 bool* has_value) { |
85 PROPVARIANT variant_value = {}; | 81 PROPVARIANT variant_value = {}; |
86 if (SUCCEEDED(new_data->GetSensorValue(property, &variant_value))) { | 82 if (SUCCEEDED(new_data->GetSensorValue(property, &variant_value))) { |
87 if (variant_value.vt == VT_R8) | 83 if (variant_value.vt == VT_R8) |
88 *value = variant_value.dblVal; | 84 *value = variant_value.dblVal; |
89 else if (variant_value.vt == VT_R4) | 85 else if (variant_value.vt == VT_R4) |
90 *value = variant_value.fltVal; | 86 *value = variant_value.fltVal; |
91 *has_value = true; | 87 *has_value = true; |
92 } else { | 88 } else { |
93 *value = 0; | 89 *value = 0; |
94 *has_value = false; | 90 *has_value = false; |
95 } | 91 } |
96 } | 92 } |
97 | 93 |
98 private: | 94 private: |
99 | |
100 DISALLOW_COPY_AND_ASSIGN(SensorEventSink); | 95 DISALLOW_COPY_AND_ASSIGN(SensorEventSink); |
101 }; | 96 }; |
102 | 97 |
103 class DataFetcherSharedMemory::SensorEventSinkOrientation | 98 class DataFetcherSharedMemory::SensorEventSinkOrientation |
104 : public DataFetcherSharedMemory::SensorEventSink { | 99 : public DataFetcherSharedMemory::SensorEventSink { |
105 public: | 100 public: |
106 explicit SensorEventSinkOrientation( | 101 explicit SensorEventSinkOrientation( |
107 DeviceOrientationHardwareBuffer* const buffer) : buffer_(buffer) {} | 102 DeviceOrientationHardwareBuffer* const buffer) |
| 103 : buffer_(buffer) {} |
108 ~SensorEventSinkOrientation() override {} | 104 ~SensorEventSinkOrientation() override {} |
109 | 105 |
110 protected: | 106 protected: |
111 bool UpdateSharedMemoryBuffer( | 107 bool UpdateSharedMemoryBuffer(ISensor* sensor, |
112 ISensor* sensor, ISensorDataReport* new_data) override { | 108 ISensorDataReport* new_data) override { |
113 double alpha, beta, gamma; | 109 double alpha, beta, gamma; |
114 bool has_alpha, has_beta, has_gamma; | 110 bool has_alpha, has_beta, has_gamma; |
115 | 111 |
116 GetSensorValue(SENSOR_DATA_TYPE_TILT_X_DEGREES, new_data, &alpha, | 112 GetSensorValue(SENSOR_DATA_TYPE_TILT_X_DEGREES, new_data, &alpha, |
117 &has_alpha); | 113 &has_alpha); |
118 GetSensorValue(SENSOR_DATA_TYPE_TILT_Y_DEGREES, new_data, &beta, | 114 GetSensorValue(SENSOR_DATA_TYPE_TILT_Y_DEGREES, new_data, &beta, &has_beta); |
119 &has_beta); | |
120 GetSensorValue(SENSOR_DATA_TYPE_TILT_Z_DEGREES, new_data, &gamma, | 115 GetSensorValue(SENSOR_DATA_TYPE_TILT_Z_DEGREES, new_data, &gamma, |
121 &has_gamma); | 116 &has_gamma); |
122 | 117 |
123 if (buffer_) { | 118 if (buffer_) { |
124 buffer_->seqlock.WriteBegin(); | 119 buffer_->seqlock.WriteBegin(); |
125 buffer_->data.alpha = alpha; | 120 buffer_->data.alpha = alpha; |
126 buffer_->data.hasAlpha = has_alpha; | 121 buffer_->data.hasAlpha = has_alpha; |
127 buffer_->data.beta = beta; | 122 buffer_->data.beta = beta; |
128 buffer_->data.hasBeta = has_beta; | 123 buffer_->data.hasBeta = has_beta; |
129 buffer_->data.gamma = gamma; | 124 buffer_->data.gamma = gamma; |
130 buffer_->data.hasGamma = has_gamma; | 125 buffer_->data.hasGamma = has_gamma; |
131 buffer_->data.absolute = true; | 126 buffer_->data.absolute = true; |
(...skipping 12 matching lines...) Expand all Loading... |
144 }; | 139 }; |
145 | 140 |
146 class DataFetcherSharedMemory::SensorEventSinkMotion | 141 class DataFetcherSharedMemory::SensorEventSinkMotion |
147 : public DataFetcherSharedMemory::SensorEventSink { | 142 : public DataFetcherSharedMemory::SensorEventSink { |
148 public: | 143 public: |
149 explicit SensorEventSinkMotion(DeviceMotionHardwareBuffer* const buffer) | 144 explicit SensorEventSinkMotion(DeviceMotionHardwareBuffer* const buffer) |
150 : buffer_(buffer) {} | 145 : buffer_(buffer) {} |
151 ~SensorEventSinkMotion() override {} | 146 ~SensorEventSinkMotion() override {} |
152 | 147 |
153 protected: | 148 protected: |
154 bool UpdateSharedMemoryBuffer( | 149 bool UpdateSharedMemoryBuffer(ISensor* sensor, |
155 ISensor* sensor, ISensorDataReport* new_data) override { | 150 ISensorDataReport* new_data) override { |
156 | |
157 SENSOR_TYPE_ID sensor_type = GUID_NULL; | 151 SENSOR_TYPE_ID sensor_type = GUID_NULL; |
158 if (!SUCCEEDED(sensor->GetType(&sensor_type))) | 152 if (!SUCCEEDED(sensor->GetType(&sensor_type))) |
159 return false; | 153 return false; |
160 | 154 |
161 if (IsEqualIID(sensor_type, SENSOR_TYPE_ACCELEROMETER_3D)) { | 155 if (IsEqualIID(sensor_type, SENSOR_TYPE_ACCELEROMETER_3D)) { |
162 double acceleration_including_gravity_x; | 156 double acceleration_including_gravity_x; |
163 double acceleration_including_gravity_y; | 157 double acceleration_including_gravity_y; |
164 double acceleration_including_gravity_z; | 158 double acceleration_including_gravity_z; |
165 bool has_acceleration_including_gravity_x; | 159 bool has_acceleration_including_gravity_x; |
166 bool has_acceleration_including_gravity_y; | 160 bool has_acceleration_including_gravity_y; |
167 bool has_acceleration_including_gravity_z; | 161 bool has_acceleration_including_gravity_z; |
168 | 162 |
169 GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_X_G, new_data, | 163 GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_X_G, new_data, |
170 &acceleration_including_gravity_x, | 164 &acceleration_including_gravity_x, |
171 &has_acceleration_including_gravity_x); | 165 &has_acceleration_including_gravity_x); |
172 GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_Y_G, new_data, | 166 GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_Y_G, new_data, |
173 &acceleration_including_gravity_y, | 167 &acceleration_including_gravity_y, |
174 &has_acceleration_including_gravity_y); | 168 &has_acceleration_including_gravity_y); |
175 GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_Z_G, new_data, | 169 GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_Z_G, new_data, |
176 &acceleration_including_gravity_z, | 170 &acceleration_including_gravity_z, |
177 &has_acceleration_including_gravity_z); | 171 &has_acceleration_including_gravity_z); |
178 | 172 |
179 if (buffer_) { | 173 if (buffer_) { |
180 buffer_->seqlock.WriteBegin(); | 174 buffer_->seqlock.WriteBegin(); |
181 buffer_->data.accelerationIncludingGravityX = | 175 buffer_->data.accelerationIncludingGravityX = |
182 -acceleration_including_gravity_x * kMeanGravity; | 176 -acceleration_including_gravity_x * kMeanGravity; |
183 buffer_->data.hasAccelerationIncludingGravityX = | 177 buffer_->data.hasAccelerationIncludingGravityX = |
184 has_acceleration_including_gravity_x; | 178 has_acceleration_including_gravity_x; |
185 buffer_->data.accelerationIncludingGravityY = | 179 buffer_->data.accelerationIncludingGravityY = |
186 -acceleration_including_gravity_y * kMeanGravity; | 180 -acceleration_including_gravity_y * kMeanGravity; |
187 buffer_->data.hasAccelerationIncludingGravityY = | 181 buffer_->data.hasAccelerationIncludingGravityY = |
188 has_acceleration_including_gravity_y; | 182 has_acceleration_including_gravity_y; |
189 buffer_->data.accelerationIncludingGravityZ = | 183 buffer_->data.accelerationIncludingGravityZ = |
190 -acceleration_including_gravity_z * kMeanGravity; | 184 -acceleration_including_gravity_z * kMeanGravity; |
191 buffer_->data.hasAccelerationIncludingGravityZ = | 185 buffer_->data.hasAccelerationIncludingGravityZ = |
192 has_acceleration_including_gravity_z; | 186 has_acceleration_including_gravity_z; |
193 // TODO(timvolodine): consider setting this after all | 187 // TODO(timvolodine): consider setting this after all |
194 // sensors have fired. | 188 // sensors have fired. |
195 buffer_->data.allAvailableSensorsAreActive = true; | 189 buffer_->data.allAvailableSensorsAreActive = true; |
196 buffer_->seqlock.WriteEnd(); | 190 buffer_->seqlock.WriteEnd(); |
197 } | 191 } |
198 | 192 |
199 } else if (IsEqualIID(sensor_type, SENSOR_TYPE_GYROMETER_3D)) { | 193 } else if (IsEqualIID(sensor_type, SENSOR_TYPE_GYROMETER_3D)) { |
200 double alpha, beta, gamma; | 194 double alpha, beta, gamma; |
201 bool has_alpha, has_beta, has_gamma; | 195 bool has_alpha, has_beta, has_gamma; |
202 | 196 |
203 GetSensorValue(SENSOR_DATA_TYPE_ANGULAR_VELOCITY_X_DEGREES_PER_SECOND, | 197 GetSensorValue(SENSOR_DATA_TYPE_ANGULAR_VELOCITY_X_DEGREES_PER_SECOND, |
204 new_data, &alpha, &has_alpha); | 198 new_data, &alpha, &has_alpha); |
205 GetSensorValue(SENSOR_DATA_TYPE_ANGULAR_VELOCITY_Y_DEGREES_PER_SECOND, | 199 GetSensorValue(SENSOR_DATA_TYPE_ANGULAR_VELOCITY_Y_DEGREES_PER_SECOND, |
206 new_data, &beta, &has_beta); | 200 new_data, &beta, &has_beta); |
207 GetSensorValue(SENSOR_DATA_TYPE_ANGULAR_VELOCITY_Z_DEGREES_PER_SECOND, | 201 GetSensorValue(SENSOR_DATA_TYPE_ANGULAR_VELOCITY_Z_DEGREES_PER_SECOND, |
208 new_data, &gamma, &has_gamma); | 202 new_data, &gamma, &has_gamma); |
209 | 203 |
210 if (buffer_) { | 204 if (buffer_) { |
211 buffer_->seqlock.WriteBegin(); | 205 buffer_->seqlock.WriteBegin(); |
212 buffer_->data.rotationRateAlpha = alpha; | 206 buffer_->data.rotationRateAlpha = alpha; |
213 buffer_->data.hasRotationRateAlpha = has_alpha; | 207 buffer_->data.hasRotationRateAlpha = has_alpha; |
214 buffer_->data.rotationRateBeta = beta; | 208 buffer_->data.rotationRateBeta = beta; |
215 buffer_->data.hasRotationRateBeta = has_beta; | 209 buffer_->data.hasRotationRateBeta = has_beta; |
216 buffer_->data.rotationRateGamma = gamma; | 210 buffer_->data.rotationRateGamma = gamma; |
217 buffer_->data.hasRotationRateGamma = has_gamma; | 211 buffer_->data.hasRotationRateGamma = has_gamma; |
218 buffer_->data.allAvailableSensorsAreActive = true; | 212 buffer_->data.allAvailableSensorsAreActive = true; |
(...skipping 12 matching lines...) Expand all Loading... |
231 | 225 |
232 class DataFetcherSharedMemory::SensorEventSinkLight | 226 class DataFetcherSharedMemory::SensorEventSinkLight |
233 : public DataFetcherSharedMemory::SensorEventSink { | 227 : public DataFetcherSharedMemory::SensorEventSink { |
234 public: | 228 public: |
235 explicit SensorEventSinkLight(DeviceLightHardwareBuffer* const buffer) | 229 explicit SensorEventSinkLight(DeviceLightHardwareBuffer* const buffer) |
236 : buffer_(buffer) {} | 230 : buffer_(buffer) {} |
237 ~SensorEventSinkLight() override {} | 231 ~SensorEventSinkLight() override {} |
238 | 232 |
239 protected: | 233 protected: |
240 bool UpdateSharedMemoryBuffer(ISensor* sensor, | 234 bool UpdateSharedMemoryBuffer(ISensor* sensor, |
241 ISensorDataReport* new_data) override { | 235 ISensorDataReport* new_data) override { |
242 double lux; | 236 double lux; |
243 bool has_lux; | 237 bool has_lux; |
244 | 238 |
245 GetSensorValue(SENSOR_DATA_TYPE_LIGHT_LEVEL_LUX, new_data, &lux, &has_lux); | 239 GetSensorValue(SENSOR_DATA_TYPE_LIGHT_LEVEL_LUX, new_data, &lux, &has_lux); |
246 | 240 |
247 if(!has_lux) { | 241 if (!has_lux) { |
248 // Could not get lux value. | 242 // Could not get lux value. |
249 return false; | 243 return false; |
250 } | 244 } |
251 | 245 |
252 SetLightBuffer(buffer_, lux); | 246 SetLightBuffer(buffer_, lux); |
253 | 247 |
254 return true; | 248 return true; |
255 } | 249 } |
256 | 250 |
257 private: | 251 private: |
(...skipping 12 matching lines...) Expand all Loading... |
270 } | 264 } |
271 | 265 |
272 DataFetcherSharedMemory::FetcherType DataFetcherSharedMemory::GetType() const { | 266 DataFetcherSharedMemory::FetcherType DataFetcherSharedMemory::GetType() const { |
273 return FETCHER_TYPE_SEPARATE_THREAD; | 267 return FETCHER_TYPE_SEPARATE_THREAD; |
274 } | 268 } |
275 | 269 |
276 bool DataFetcherSharedMemory::Start(ConsumerType consumer_type, void* buffer) { | 270 bool DataFetcherSharedMemory::Start(ConsumerType consumer_type, void* buffer) { |
277 DCHECK(buffer); | 271 DCHECK(buffer); |
278 | 272 |
279 switch (consumer_type) { | 273 switch (consumer_type) { |
280 case CONSUMER_TYPE_ORIENTATION: | 274 case CONSUMER_TYPE_ORIENTATION: { |
281 { | 275 orientation_buffer_ = |
282 orientation_buffer_ = | 276 static_cast<DeviceOrientationHardwareBuffer*>(buffer); |
283 static_cast<DeviceOrientationHardwareBuffer*>(buffer); | 277 scoped_refptr<SensorEventSink> sink( |
284 scoped_refptr<SensorEventSink> sink( | 278 new SensorEventSinkOrientation(orientation_buffer_)); |
285 new SensorEventSinkOrientation(orientation_buffer_)); | 279 bool inclinometer_available = RegisterForSensor( |
286 bool inclinometer_available = RegisterForSensor( | 280 SENSOR_TYPE_INCLINOMETER_3D, sensor_inclinometer_.Receive(), sink); |
287 SENSOR_TYPE_INCLINOMETER_3D, sensor_inclinometer_.Receive(), sink); | 281 UMA_HISTOGRAM_BOOLEAN("InertialSensor.InclinometerWindowsAvailable", |
288 UMA_HISTOGRAM_BOOLEAN("InertialSensor.InclinometerWindowsAvailable", | 282 inclinometer_available); |
289 inclinometer_available); | 283 if (inclinometer_available) |
290 if (inclinometer_available) | 284 return true; |
291 return true; | 285 // if no sensors are available set buffer to ready, to fire null-events. |
292 // if no sensors are available set buffer to ready, to fire null-events. | 286 SetBufferAvailableState(consumer_type, true); |
293 SetBufferAvailableState(consumer_type, true); | 287 } break; |
| 288 case CONSUMER_TYPE_MOTION: { |
| 289 motion_buffer_ = static_cast<DeviceMotionHardwareBuffer*>(buffer); |
| 290 scoped_refptr<SensorEventSink> sink( |
| 291 new SensorEventSinkMotion(motion_buffer_)); |
| 292 bool accelerometer_available = RegisterForSensor( |
| 293 SENSOR_TYPE_ACCELEROMETER_3D, sensor_accelerometer_.Receive(), sink); |
| 294 bool gyrometer_available = RegisterForSensor( |
| 295 SENSOR_TYPE_GYROMETER_3D, sensor_gyrometer_.Receive(), sink); |
| 296 UMA_HISTOGRAM_BOOLEAN("InertialSensor.AccelerometerWindowsAvailable", |
| 297 accelerometer_available); |
| 298 UMA_HISTOGRAM_BOOLEAN("InertialSensor.GyrometerWindowsAvailable", |
| 299 gyrometer_available); |
| 300 if (accelerometer_available || gyrometer_available) { |
| 301 motion_buffer_->seqlock.WriteBegin(); |
| 302 motion_buffer_->data.interval = GetInterval().InMilliseconds(); |
| 303 motion_buffer_->seqlock.WriteEnd(); |
| 304 return true; |
294 } | 305 } |
295 break; | 306 // if no sensors are available set buffer to ready, to fire null-events. |
296 case CONSUMER_TYPE_MOTION: | 307 SetBufferAvailableState(consumer_type, true); |
297 { | 308 } break; |
298 motion_buffer_ = static_cast<DeviceMotionHardwareBuffer*>(buffer); | 309 case CONSUMER_TYPE_LIGHT: { |
299 scoped_refptr<SensorEventSink> sink( | 310 light_buffer_ = static_cast<DeviceLightHardwareBuffer*>(buffer); |
300 new SensorEventSinkMotion(motion_buffer_)); | 311 scoped_refptr<SensorEventSink> sink( |
301 bool accelerometer_available = RegisterForSensor( | 312 new SensorEventSinkLight(light_buffer_)); |
302 SENSOR_TYPE_ACCELEROMETER_3D, sensor_accelerometer_.Receive(), | 313 bool sensor_light_available = RegisterForSensor( |
303 sink); | 314 SENSOR_TYPE_AMBIENT_LIGHT, sensor_light_.Receive(), sink); |
304 bool gyrometer_available = RegisterForSensor( | 315 if (sensor_light_available) { |
305 SENSOR_TYPE_GYROMETER_3D, sensor_gyrometer_.Receive(), sink); | 316 SetLightBuffer(light_buffer_, -1); |
306 UMA_HISTOGRAM_BOOLEAN("InertialSensor.AccelerometerWindowsAvailable", | 317 return true; |
307 accelerometer_available); | |
308 UMA_HISTOGRAM_BOOLEAN("InertialSensor.GyrometerWindowsAvailable", | |
309 gyrometer_available); | |
310 if (accelerometer_available || gyrometer_available) { | |
311 motion_buffer_->seqlock.WriteBegin(); | |
312 motion_buffer_->data.interval = GetInterval().InMilliseconds(); | |
313 motion_buffer_->seqlock.WriteEnd(); | |
314 return true; | |
315 } | |
316 // if no sensors are available set buffer to ready, to fire null-events. | |
317 SetBufferAvailableState(consumer_type, true); | |
318 } | 318 } |
319 break; | |
320 case CONSUMER_TYPE_LIGHT: | |
321 { | |
322 light_buffer_ = static_cast<DeviceLightHardwareBuffer*>(buffer); | |
323 scoped_refptr<SensorEventSink> sink( | |
324 new SensorEventSinkLight(light_buffer_)); | |
325 bool sensor_light_available = RegisterForSensor( | |
326 SENSOR_TYPE_AMBIENT_LIGHT, sensor_light_.Receive(), sink); | |
327 if (sensor_light_available) { | |
328 SetLightBuffer(light_buffer_, -1); | |
329 return true; | |
330 } | |
331 | 319 |
332 // if no sensors are available, fire an Infinity event. | 320 // if no sensors are available, fire an Infinity event. |
333 SetLightBuffer(light_buffer_, std::numeric_limits<double>::infinity()); | 321 SetLightBuffer(light_buffer_, std::numeric_limits<double>::infinity()); |
334 } | 322 } break; |
335 break; | |
336 default: | 323 default: |
337 NOTREACHED(); | 324 NOTREACHED(); |
338 } | 325 } |
339 return false; | 326 return false; |
340 } | 327 } |
341 | 328 |
342 bool DataFetcherSharedMemory::Stop(ConsumerType consumer_type) { | 329 bool DataFetcherSharedMemory::Stop(ConsumerType consumer_type) { |
343 DisableSensors(consumer_type); | 330 DisableSensors(consumer_type); |
344 switch (consumer_type) { | 331 switch (consumer_type) { |
345 case CONSUMER_TYPE_ORIENTATION: | 332 case CONSUMER_TYPE_ORIENTATION: |
(...skipping 20 matching lines...) Expand all Loading... |
366 scoped_refptr<SensorEventSink> event_sink) { | 353 scoped_refptr<SensorEventSink> event_sink) { |
367 if (base::win::GetVersion() < base::win::VERSION_WIN7) | 354 if (base::win::GetVersion() < base::win::VERSION_WIN7) |
368 return false; | 355 return false; |
369 | 356 |
370 base::win::ScopedComPtr<ISensorManager> sensor_manager; | 357 base::win::ScopedComPtr<ISensorManager> sensor_manager; |
371 HRESULT hr = sensor_manager.CreateInstance(CLSID_SensorManager); | 358 HRESULT hr = sensor_manager.CreateInstance(CLSID_SensorManager); |
372 if (FAILED(hr) || !sensor_manager.get()) | 359 if (FAILED(hr) || !sensor_manager.get()) |
373 return false; | 360 return false; |
374 | 361 |
375 base::win::ScopedComPtr<ISensorCollection> sensor_collection; | 362 base::win::ScopedComPtr<ISensorCollection> sensor_collection; |
376 hr = sensor_manager->GetSensorsByType( | 363 hr = sensor_manager->GetSensorsByType(sensor_type, |
377 sensor_type, sensor_collection.Receive()); | 364 sensor_collection.Receive()); |
378 | 365 |
379 if (FAILED(hr) || !sensor_collection.get()) | 366 if (FAILED(hr) || !sensor_collection.get()) |
380 return false; | 367 return false; |
381 | 368 |
382 ULONG count = 0; | 369 ULONG count = 0; |
383 hr = sensor_collection->GetCount(&count); | 370 hr = sensor_collection->GetCount(&count); |
384 if (FAILED(hr) || !count) | 371 if (FAILED(hr) || !count) |
385 return false; | 372 return false; |
386 | 373 |
387 hr = sensor_collection->GetAt(0, sensor); | 374 hr = sensor_collection->GetAt(0, sensor); |
388 if (FAILED(hr) || !(*sensor)) | 375 if (FAILED(hr) || !(*sensor)) |
389 return false; | 376 return false; |
390 | 377 |
391 base::win::ScopedComPtr<IPortableDeviceValues> device_values; | 378 base::win::ScopedComPtr<IPortableDeviceValues> device_values; |
392 if (SUCCEEDED(device_values.CreateInstance(CLSID_PortableDeviceValues))) { | 379 if (SUCCEEDED(device_values.CreateInstance(CLSID_PortableDeviceValues))) { |
393 if (SUCCEEDED(device_values->SetUnsignedIntegerValue( | 380 if (SUCCEEDED(device_values->SetUnsignedIntegerValue( |
394 SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL, | 381 SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL, |
395 GetInterval().InMilliseconds()))) { | 382 GetInterval().InMilliseconds()))) { |
396 base::win::ScopedComPtr<IPortableDeviceValues> return_values; | 383 base::win::ScopedComPtr<IPortableDeviceValues> return_values; |
397 (*sensor)->SetProperties(device_values.get(), return_values.Receive()); | 384 (*sensor)->SetProperties(device_values.get(), return_values.Receive()); |
398 } | 385 } |
399 } | 386 } |
400 | 387 |
401 base::win::ScopedComPtr<ISensorEvents> sensor_events; | 388 base::win::ScopedComPtr<ISensorEvents> sensor_events; |
402 hr = event_sink->QueryInterface( | 389 hr = event_sink->QueryInterface(__uuidof(ISensorEvents), |
403 __uuidof(ISensorEvents), sensor_events.ReceiveVoid()); | 390 sensor_events.ReceiveVoid()); |
404 if (FAILED(hr) || !sensor_events.get()) | 391 if (FAILED(hr) || !sensor_events.get()) |
405 return false; | 392 return false; |
406 | 393 |
407 hr = (*sensor)->SetEventSink(sensor_events.get()); | 394 hr = (*sensor)->SetEventSink(sensor_events.get()); |
408 if (FAILED(hr)) | 395 if (FAILED(hr)) |
409 return false; | 396 return false; |
410 | 397 |
411 return true; | 398 return true; |
412 } | 399 } |
413 | 400 |
414 void DataFetcherSharedMemory::DisableSensors(ConsumerType consumer_type) { | 401 void DataFetcherSharedMemory::DisableSensors(ConsumerType consumer_type) { |
415 switch(consumer_type) { | 402 switch (consumer_type) { |
416 case CONSUMER_TYPE_ORIENTATION: | 403 case CONSUMER_TYPE_ORIENTATION: |
417 if (sensor_inclinometer_.get()) { | 404 if (sensor_inclinometer_.get()) { |
418 sensor_inclinometer_->SetEventSink(nullptr); | 405 sensor_inclinometer_->SetEventSink(nullptr); |
419 sensor_inclinometer_.Release(); | 406 sensor_inclinometer_.Release(); |
420 } | 407 } |
421 break; | 408 break; |
422 case CONSUMER_TYPE_MOTION: | 409 case CONSUMER_TYPE_MOTION: |
423 if (sensor_accelerometer_.get()) { | 410 if (sensor_accelerometer_.get()) { |
424 sensor_accelerometer_->SetEventSink(nullptr); | 411 sensor_accelerometer_->SetEventSink(nullptr); |
425 sensor_accelerometer_.Release(); | 412 sensor_accelerometer_.Release(); |
426 } | 413 } |
427 if (sensor_gyrometer_.get()) { | 414 if (sensor_gyrometer_.get()) { |
428 sensor_gyrometer_->SetEventSink(nullptr); | 415 sensor_gyrometer_->SetEventSink(nullptr); |
429 sensor_gyrometer_.Release(); | 416 sensor_gyrometer_.Release(); |
430 } | 417 } |
431 break; | 418 break; |
432 case CONSUMER_TYPE_LIGHT: | 419 case CONSUMER_TYPE_LIGHT: |
433 if (sensor_light_.get()) { | 420 if (sensor_light_.get()) { |
434 sensor_light_->SetEventSink(nullptr); | 421 sensor_light_->SetEventSink(nullptr); |
435 sensor_light_.Release(); | 422 sensor_light_.Release(); |
436 } | 423 } |
437 break; | 424 break; |
438 default: | 425 default: |
439 NOTREACHED(); | 426 NOTREACHED(); |
440 } | 427 } |
441 } | 428 } |
442 | 429 |
443 void DataFetcherSharedMemory::SetBufferAvailableState( | 430 void DataFetcherSharedMemory::SetBufferAvailableState( |
444 ConsumerType consumer_type, bool enabled) { | 431 ConsumerType consumer_type, |
445 switch(consumer_type) { | 432 bool enabled) { |
| 433 switch (consumer_type) { |
446 case CONSUMER_TYPE_ORIENTATION: | 434 case CONSUMER_TYPE_ORIENTATION: |
447 if (orientation_buffer_) { | 435 if (orientation_buffer_) { |
448 orientation_buffer_->seqlock.WriteBegin(); | 436 orientation_buffer_->seqlock.WriteBegin(); |
449 orientation_buffer_->data.allAvailableSensorsAreActive = enabled; | 437 orientation_buffer_->data.allAvailableSensorsAreActive = enabled; |
450 orientation_buffer_->seqlock.WriteEnd(); | 438 orientation_buffer_->seqlock.WriteEnd(); |
451 } | 439 } |
452 break; | 440 break; |
453 case CONSUMER_TYPE_MOTION: | 441 case CONSUMER_TYPE_MOTION: |
454 if (motion_buffer_) { | 442 if (motion_buffer_) { |
455 motion_buffer_->seqlock.WriteBegin(); | 443 motion_buffer_->seqlock.WriteBegin(); |
456 motion_buffer_->data.allAvailableSensorsAreActive = enabled; | 444 motion_buffer_->data.allAvailableSensorsAreActive = enabled; |
457 motion_buffer_->seqlock.WriteEnd(); | 445 motion_buffer_->seqlock.WriteEnd(); |
458 } | 446 } |
459 break; | 447 break; |
460 default: | 448 default: |
461 NOTREACHED(); | 449 NOTREACHED(); |
462 } | 450 } |
463 } | 451 } |
464 | 452 |
465 } // namespace content | 453 } // namespace content |
OLD | NEW |