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/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/macros.h" | 13 #include "base/macros.h" |
14 #include "base/metrics/histogram_macros.h" | 14 #include "base/metrics/histogram_macros.h" |
15 #include "base/win/iunknown_impl.h" | 15 #include "base/win/iunknown_impl.h" |
16 #include "base/win/windows_version.h" | 16 #include "base/win/windows_version.h" |
17 | 17 |
18 namespace { | 18 namespace { |
19 | 19 |
20 const double kMeanGravity = 9.80665; | 20 const double kMeanGravity = 9.80665; |
21 | 21 |
22 void SetLightBuffer(content::DeviceLightHardwareBuffer* buffer, double lux) { | 22 void SetLightBuffer(device::DeviceLightHardwareBuffer* buffer, double lux) { |
23 DCHECK(buffer); | 23 DCHECK(buffer); |
24 buffer->seqlock.WriteBegin(); | 24 buffer->seqlock.WriteBegin(); |
25 buffer->data.value = lux; | 25 buffer->data.value = lux; |
26 buffer->seqlock.WriteEnd(); | 26 buffer->seqlock.WriteEnd(); |
27 } | 27 } |
28 | 28 |
29 } // namespace | 29 } // namespace |
30 | 30 |
31 | 31 namespace device { |
32 namespace content { | |
33 | 32 |
34 class DataFetcherSharedMemory::SensorEventSink | 33 class DataFetcherSharedMemory::SensorEventSink |
35 : public ISensorEvents, public base::win::IUnknownImpl { | 34 : public ISensorEvents, |
| 35 public base::win::IUnknownImpl { |
36 public: | 36 public: |
37 SensorEventSink() {} | 37 SensorEventSink() {} |
38 ~SensorEventSink() override {} | 38 ~SensorEventSink() override {} |
39 | 39 |
40 // IUnknown interface | 40 // IUnknown interface |
41 ULONG STDMETHODCALLTYPE AddRef() override { | 41 ULONG STDMETHODCALLTYPE AddRef() override { return IUnknownImpl::AddRef(); } |
42 return IUnknownImpl::AddRef(); | |
43 } | |
44 | 42 |
45 ULONG STDMETHODCALLTYPE Release() override { | 43 ULONG STDMETHODCALLTYPE Release() override { return IUnknownImpl::Release(); } |
46 return IUnknownImpl::Release(); | |
47 } | |
48 | 44 |
49 STDMETHODIMP QueryInterface(REFIID riid, void** ppv) override { | 45 STDMETHODIMP QueryInterface(REFIID riid, void** ppv) override { |
50 if (riid == __uuidof(ISensorEvents)) { | 46 if (riid == __uuidof(ISensorEvents)) { |
51 *ppv = static_cast<ISensorEvents*>(this); | 47 *ppv = static_cast<ISensorEvents*>(this); |
52 AddRef(); | 48 AddRef(); |
53 return S_OK; | 49 return S_OK; |
54 } | 50 } |
55 return IUnknownImpl::QueryInterface(riid, ppv); | 51 return IUnknownImpl::QueryInterface(riid, ppv); |
56 } | 52 } |
57 | 53 |
58 // ISensorEvents interface | 54 // ISensorEvents interface |
59 STDMETHODIMP OnEvent(ISensor* sensor, | 55 STDMETHODIMP OnEvent(ISensor* sensor, |
60 REFGUID event_id, | 56 REFGUID event_id, |
61 IPortableDeviceValues* event_data) override { | 57 IPortableDeviceValues* event_data) override { |
62 return S_OK; | 58 return S_OK; |
63 } | 59 } |
64 | 60 |
65 STDMETHODIMP OnLeave(REFSENSOR_ID sensor_id) override { | 61 STDMETHODIMP OnLeave(REFSENSOR_ID sensor_id) override { return S_OK; } |
66 return S_OK; | |
67 } | |
68 | 62 |
69 STDMETHODIMP OnStateChanged(ISensor* sensor, SensorState state) override { | 63 STDMETHODIMP OnStateChanged(ISensor* sensor, SensorState state) override { |
70 return S_OK; | 64 return S_OK; |
71 } | 65 } |
72 | 66 |
73 STDMETHODIMP OnDataUpdated(ISensor* sensor, | 67 STDMETHODIMP OnDataUpdated(ISensor* sensor, |
74 ISensorDataReport* new_data) override { | 68 ISensorDataReport* new_data) override { |
75 if (nullptr == new_data || nullptr == sensor) | 69 if (nullptr == new_data || nullptr == sensor) |
76 return E_INVALIDARG; | 70 return E_INVALIDARG; |
77 return UpdateSharedMemoryBuffer(sensor, new_data) ? S_OK : E_FAIL; | 71 return UpdateSharedMemoryBuffer(sensor, new_data) ? S_OK : E_FAIL; |
78 } | 72 } |
79 | 73 |
80 protected: | 74 protected: |
81 virtual bool UpdateSharedMemoryBuffer( | 75 virtual bool UpdateSharedMemoryBuffer(ISensor* sensor, |
82 ISensor* sensor, ISensorDataReport* new_data) = 0; | 76 ISensorDataReport* new_data) = 0; |
83 | 77 |
84 void GetSensorValue(REFPROPERTYKEY property, ISensorDataReport* new_data, | 78 void GetSensorValue(REFPROPERTYKEY property, |
85 double* value, bool* has_value) { | 79 ISensorDataReport* new_data, |
| 80 double* value, |
| 81 bool* has_value) { |
86 PROPVARIANT variant_value = {}; | 82 PROPVARIANT variant_value = {}; |
87 if (SUCCEEDED(new_data->GetSensorValue(property, &variant_value))) { | 83 if (SUCCEEDED(new_data->GetSensorValue(property, &variant_value))) { |
88 if (variant_value.vt == VT_R8) | 84 if (variant_value.vt == VT_R8) |
89 *value = variant_value.dblVal; | 85 *value = variant_value.dblVal; |
90 else if (variant_value.vt == VT_R4) | 86 else if (variant_value.vt == VT_R4) |
91 *value = variant_value.fltVal; | 87 *value = variant_value.fltVal; |
92 *has_value = true; | 88 *has_value = true; |
93 } else { | 89 } else { |
94 *value = 0; | 90 *value = 0; |
95 *has_value = false; | 91 *has_value = false; |
96 } | 92 } |
97 } | 93 } |
98 | 94 |
99 private: | 95 private: |
100 | |
101 DISALLOW_COPY_AND_ASSIGN(SensorEventSink); | 96 DISALLOW_COPY_AND_ASSIGN(SensorEventSink); |
102 }; | 97 }; |
103 | 98 |
104 class DataFetcherSharedMemory::SensorEventSinkOrientation | 99 class DataFetcherSharedMemory::SensorEventSinkOrientation |
105 : public DataFetcherSharedMemory::SensorEventSink { | 100 : public DataFetcherSharedMemory::SensorEventSink { |
106 public: | 101 public: |
107 explicit SensorEventSinkOrientation( | 102 explicit SensorEventSinkOrientation( |
108 DeviceOrientationHardwareBuffer* const buffer) : buffer_(buffer) {} | 103 DeviceOrientationHardwareBuffer* const buffer) |
| 104 : buffer_(buffer) {} |
109 ~SensorEventSinkOrientation() override {} | 105 ~SensorEventSinkOrientation() override {} |
110 | 106 |
111 protected: | 107 protected: |
112 bool UpdateSharedMemoryBuffer( | 108 bool UpdateSharedMemoryBuffer(ISensor* sensor, |
113 ISensor* sensor, ISensorDataReport* new_data) override { | 109 ISensorDataReport* new_data) override { |
114 double alpha, beta, gamma; | 110 double alpha, beta, gamma; |
115 bool has_alpha, has_beta, has_gamma; | 111 bool has_alpha, has_beta, has_gamma; |
116 | 112 |
117 GetSensorValue(SENSOR_DATA_TYPE_TILT_X_DEGREES, new_data, &beta, | 113 GetSensorValue(SENSOR_DATA_TYPE_TILT_X_DEGREES, new_data, &beta, &has_beta); |
118 &has_beta); | |
119 GetSensorValue(SENSOR_DATA_TYPE_TILT_Y_DEGREES, new_data, &gamma, | 114 GetSensorValue(SENSOR_DATA_TYPE_TILT_Y_DEGREES, new_data, &gamma, |
120 &has_gamma); | 115 &has_gamma); |
121 GetSensorValue(SENSOR_DATA_TYPE_TILT_Z_DEGREES, new_data, &alpha, | 116 GetSensorValue(SENSOR_DATA_TYPE_TILT_Z_DEGREES, new_data, &alpha, |
122 &has_alpha); | 117 &has_alpha); |
123 | 118 |
124 if (buffer_) { | 119 if (buffer_) { |
125 buffer_->seqlock.WriteBegin(); | 120 buffer_->seqlock.WriteBegin(); |
126 buffer_->data.alpha = alpha; | 121 buffer_->data.alpha = alpha; |
127 buffer_->data.hasAlpha = has_alpha; | 122 buffer_->data.hasAlpha = has_alpha; |
128 buffer_->data.beta = beta; | 123 buffer_->data.beta = beta; |
129 buffer_->data.hasBeta = has_beta; | 124 buffer_->data.hasBeta = has_beta; |
130 buffer_->data.gamma = gamma; | 125 buffer_->data.gamma = gamma; |
131 buffer_->data.hasGamma = has_gamma; | 126 buffer_->data.hasGamma = has_gamma; |
132 buffer_->data.absolute = has_alpha || has_beta || has_gamma; | 127 buffer_->data.absolute = has_alpha || has_beta || has_gamma; |
(...skipping 11 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: |
258 DeviceLightHardwareBuffer* const buffer_; | 252 DeviceLightHardwareBuffer* const buffer_; |
259 | 253 |
260 DISALLOW_COPY_AND_ASSIGN(SensorEventSinkLight); | 254 DISALLOW_COPY_AND_ASSIGN(SensorEventSinkLight); |
261 }; | 255 }; |
262 | 256 |
263 DataFetcherSharedMemory::DataFetcherSharedMemory() {} | 257 DataFetcherSharedMemory::DataFetcherSharedMemory() {} |
264 | 258 |
265 DataFetcherSharedMemory::~DataFetcherSharedMemory() { | 259 DataFetcherSharedMemory::~DataFetcherSharedMemory() {} |
266 } | |
267 | 260 |
268 DataFetcherSharedMemory::FetcherType DataFetcherSharedMemory::GetType() const { | 261 DataFetcherSharedMemory::FetcherType DataFetcherSharedMemory::GetType() const { |
269 return FETCHER_TYPE_SEPARATE_THREAD; | 262 return FETCHER_TYPE_SEPARATE_THREAD; |
270 } | 263 } |
271 | 264 |
272 bool DataFetcherSharedMemory::Start(ConsumerType consumer_type, void* buffer) { | 265 bool DataFetcherSharedMemory::Start(ConsumerType consumer_type, void* buffer) { |
273 DCHECK(buffer); | 266 DCHECK(buffer); |
274 | 267 |
275 switch (consumer_type) { | 268 switch (consumer_type) { |
276 case CONSUMER_TYPE_ORIENTATION: | 269 case CONSUMER_TYPE_ORIENTATION: { |
277 { | 270 orientation_buffer_ = |
278 orientation_buffer_ = | 271 static_cast<DeviceOrientationHardwareBuffer*>(buffer); |
279 static_cast<DeviceOrientationHardwareBuffer*>(buffer); | 272 scoped_refptr<SensorEventSink> sink( |
280 scoped_refptr<SensorEventSink> sink( | 273 new SensorEventSinkOrientation(orientation_buffer_)); |
281 new SensorEventSinkOrientation(orientation_buffer_)); | 274 bool inclinometer_available = RegisterForSensor( |
282 bool inclinometer_available = RegisterForSensor( | 275 SENSOR_TYPE_INCLINOMETER_3D, sensor_inclinometer_.Receive(), sink); |
283 SENSOR_TYPE_INCLINOMETER_3D, sensor_inclinometer_.Receive(), sink); | 276 UMA_HISTOGRAM_BOOLEAN("InertialSensor.InclinometerWindowsAvailable", |
284 UMA_HISTOGRAM_BOOLEAN("InertialSensor.InclinometerWindowsAvailable", | 277 inclinometer_available); |
285 inclinometer_available); | 278 if (inclinometer_available) |
286 if (inclinometer_available) | 279 return true; |
287 return true; | 280 // if no sensors are available set buffer to ready, to fire null-events. |
288 // if no sensors are available set buffer to ready, to fire null-events. | 281 SetBufferAvailableState(consumer_type, true); |
289 SetBufferAvailableState(consumer_type, true); | 282 } break; |
| 283 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: { |
| 284 orientation_absolute_buffer_ = |
| 285 static_cast<DeviceOrientationHardwareBuffer*>(buffer); |
| 286 scoped_refptr<SensorEventSink> sink( |
| 287 new SensorEventSinkOrientation(orientation_absolute_buffer_)); |
| 288 // Currently we use the same sensor as for orientation which provides |
| 289 // absolute angles. |
| 290 bool inclinometer_available = |
| 291 RegisterForSensor(SENSOR_TYPE_INCLINOMETER_3D, |
| 292 sensor_inclinometer_absolute_.Receive(), sink); |
| 293 // TODO(timvolodine): consider adding UMA. |
| 294 if (inclinometer_available) |
| 295 return true; |
| 296 // if no sensors are available set buffer to ready, to fire null-events. |
| 297 SetBufferAvailableState(consumer_type, true); |
| 298 } break; |
| 299 case CONSUMER_TYPE_MOTION: { |
| 300 motion_buffer_ = static_cast<DeviceMotionHardwareBuffer*>(buffer); |
| 301 scoped_refptr<SensorEventSink> sink( |
| 302 new SensorEventSinkMotion(motion_buffer_)); |
| 303 bool accelerometer_available = RegisterForSensor( |
| 304 SENSOR_TYPE_ACCELEROMETER_3D, sensor_accelerometer_.Receive(), sink); |
| 305 bool gyrometer_available = RegisterForSensor( |
| 306 SENSOR_TYPE_GYROMETER_3D, sensor_gyrometer_.Receive(), sink); |
| 307 UMA_HISTOGRAM_BOOLEAN("InertialSensor.AccelerometerWindowsAvailable", |
| 308 accelerometer_available); |
| 309 UMA_HISTOGRAM_BOOLEAN("InertialSensor.GyrometerWindowsAvailable", |
| 310 gyrometer_available); |
| 311 if (accelerometer_available || gyrometer_available) { |
| 312 motion_buffer_->seqlock.WriteBegin(); |
| 313 motion_buffer_->data.interval = GetInterval().InMilliseconds(); |
| 314 motion_buffer_->seqlock.WriteEnd(); |
| 315 return true; |
290 } | 316 } |
291 break; | 317 // if no sensors are available set buffer to ready, to fire null-events. |
292 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: | 318 SetBufferAvailableState(consumer_type, true); |
293 { | 319 } break; |
294 orientation_absolute_buffer_ = | 320 case CONSUMER_TYPE_LIGHT: { |
295 static_cast<DeviceOrientationHardwareBuffer*>(buffer); | 321 light_buffer_ = static_cast<DeviceLightHardwareBuffer*>(buffer); |
296 scoped_refptr<SensorEventSink> sink( | 322 scoped_refptr<SensorEventSink> sink( |
297 new SensorEventSinkOrientation(orientation_absolute_buffer_)); | 323 new SensorEventSinkLight(light_buffer_)); |
298 // Currently we use the same sensor as for orientation which provides | 324 bool sensor_light_available = RegisterForSensor( |
299 // absolute angles. | 325 SENSOR_TYPE_AMBIENT_LIGHT, sensor_light_.Receive(), sink); |
300 bool inclinometer_available = RegisterForSensor( | 326 if (sensor_light_available) { |
301 SENSOR_TYPE_INCLINOMETER_3D, | 327 SetLightBuffer(light_buffer_, -1); |
302 sensor_inclinometer_absolute_.Receive(), sink); | 328 return true; |
303 // TODO(timvolodine): consider adding UMA. | |
304 if (inclinometer_available) | |
305 return true; | |
306 // if no sensors are available set buffer to ready, to fire null-events. | |
307 SetBufferAvailableState(consumer_type, true); | |
308 } | 329 } |
309 break; | |
310 case CONSUMER_TYPE_MOTION: | |
311 { | |
312 motion_buffer_ = static_cast<DeviceMotionHardwareBuffer*>(buffer); | |
313 scoped_refptr<SensorEventSink> sink( | |
314 new SensorEventSinkMotion(motion_buffer_)); | |
315 bool accelerometer_available = RegisterForSensor( | |
316 SENSOR_TYPE_ACCELEROMETER_3D, sensor_accelerometer_.Receive(), | |
317 sink); | |
318 bool gyrometer_available = RegisterForSensor( | |
319 SENSOR_TYPE_GYROMETER_3D, sensor_gyrometer_.Receive(), sink); | |
320 UMA_HISTOGRAM_BOOLEAN("InertialSensor.AccelerometerWindowsAvailable", | |
321 accelerometer_available); | |
322 UMA_HISTOGRAM_BOOLEAN("InertialSensor.GyrometerWindowsAvailable", | |
323 gyrometer_available); | |
324 if (accelerometer_available || gyrometer_available) { | |
325 motion_buffer_->seqlock.WriteBegin(); | |
326 motion_buffer_->data.interval = GetInterval().InMilliseconds(); | |
327 motion_buffer_->seqlock.WriteEnd(); | |
328 return true; | |
329 } | |
330 // if no sensors are available set buffer to ready, to fire null-events. | |
331 SetBufferAvailableState(consumer_type, true); | |
332 } | |
333 break; | |
334 case CONSUMER_TYPE_LIGHT: | |
335 { | |
336 light_buffer_ = static_cast<DeviceLightHardwareBuffer*>(buffer); | |
337 scoped_refptr<SensorEventSink> sink( | |
338 new SensorEventSinkLight(light_buffer_)); | |
339 bool sensor_light_available = RegisterForSensor( | |
340 SENSOR_TYPE_AMBIENT_LIGHT, sensor_light_.Receive(), sink); | |
341 if (sensor_light_available) { | |
342 SetLightBuffer(light_buffer_, -1); | |
343 return true; | |
344 } | |
345 | 330 |
346 // if no sensors are available, fire an Infinity event. | 331 // if no sensors are available, fire an Infinity event. |
347 SetLightBuffer(light_buffer_, std::numeric_limits<double>::infinity()); | 332 SetLightBuffer(light_buffer_, std::numeric_limits<double>::infinity()); |
348 } | 333 } break; |
349 break; | |
350 default: | 334 default: |
351 NOTREACHED(); | 335 NOTREACHED(); |
352 } | 336 } |
353 return false; | 337 return false; |
354 } | 338 } |
355 | 339 |
356 bool DataFetcherSharedMemory::Stop(ConsumerType consumer_type) { | 340 bool DataFetcherSharedMemory::Stop(ConsumerType consumer_type) { |
357 DisableSensors(consumer_type); | 341 DisableSensors(consumer_type); |
358 switch (consumer_type) { | 342 switch (consumer_type) { |
359 case CONSUMER_TYPE_ORIENTATION: | 343 case CONSUMER_TYPE_ORIENTATION: |
(...skipping 24 matching lines...) Expand all Loading... |
384 scoped_refptr<SensorEventSink> event_sink) { | 368 scoped_refptr<SensorEventSink> event_sink) { |
385 if (base::win::GetVersion() < base::win::VERSION_WIN7) | 369 if (base::win::GetVersion() < base::win::VERSION_WIN7) |
386 return false; | 370 return false; |
387 | 371 |
388 base::win::ScopedComPtr<ISensorManager> sensor_manager; | 372 base::win::ScopedComPtr<ISensorManager> sensor_manager; |
389 HRESULT hr = sensor_manager.CreateInstance(CLSID_SensorManager); | 373 HRESULT hr = sensor_manager.CreateInstance(CLSID_SensorManager); |
390 if (FAILED(hr) || !sensor_manager.get()) | 374 if (FAILED(hr) || !sensor_manager.get()) |
391 return false; | 375 return false; |
392 | 376 |
393 base::win::ScopedComPtr<ISensorCollection> sensor_collection; | 377 base::win::ScopedComPtr<ISensorCollection> sensor_collection; |
394 hr = sensor_manager->GetSensorsByType( | 378 hr = sensor_manager->GetSensorsByType(sensor_type, |
395 sensor_type, sensor_collection.Receive()); | 379 sensor_collection.Receive()); |
396 | 380 |
397 if (FAILED(hr) || !sensor_collection.get()) | 381 if (FAILED(hr) || !sensor_collection.get()) |
398 return false; | 382 return false; |
399 | 383 |
400 ULONG count = 0; | 384 ULONG count = 0; |
401 hr = sensor_collection->GetCount(&count); | 385 hr = sensor_collection->GetCount(&count); |
402 if (FAILED(hr) || !count) | 386 if (FAILED(hr) || !count) |
403 return false; | 387 return false; |
404 | 388 |
405 hr = sensor_collection->GetAt(0, sensor); | 389 hr = sensor_collection->GetAt(0, sensor); |
406 if (FAILED(hr) || !(*sensor)) | 390 if (FAILED(hr) || !(*sensor)) |
407 return false; | 391 return false; |
408 | 392 |
409 base::win::ScopedComPtr<IPortableDeviceValues> device_values; | 393 base::win::ScopedComPtr<IPortableDeviceValues> device_values; |
410 if (SUCCEEDED(device_values.CreateInstance(CLSID_PortableDeviceValues))) { | 394 if (SUCCEEDED(device_values.CreateInstance(CLSID_PortableDeviceValues))) { |
411 if (SUCCEEDED(device_values->SetUnsignedIntegerValue( | 395 if (SUCCEEDED(device_values->SetUnsignedIntegerValue( |
412 SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL, | 396 SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL, |
413 GetInterval().InMilliseconds()))) { | 397 GetInterval().InMilliseconds()))) { |
414 base::win::ScopedComPtr<IPortableDeviceValues> return_values; | 398 base::win::ScopedComPtr<IPortableDeviceValues> return_values; |
415 (*sensor)->SetProperties(device_values.get(), return_values.Receive()); | 399 (*sensor)->SetProperties(device_values.get(), return_values.Receive()); |
416 } | 400 } |
417 } | 401 } |
418 | 402 |
419 base::win::ScopedComPtr<ISensorEvents> sensor_events; | 403 base::win::ScopedComPtr<ISensorEvents> sensor_events; |
420 hr = event_sink->QueryInterface( | 404 hr = event_sink->QueryInterface(__uuidof(ISensorEvents), |
421 __uuidof(ISensorEvents), sensor_events.ReceiveVoid()); | 405 sensor_events.ReceiveVoid()); |
422 if (FAILED(hr) || !sensor_events.get()) | 406 if (FAILED(hr) || !sensor_events.get()) |
423 return false; | 407 return false; |
424 | 408 |
425 hr = (*sensor)->SetEventSink(sensor_events.get()); | 409 hr = (*sensor)->SetEventSink(sensor_events.get()); |
426 if (FAILED(hr)) | 410 if (FAILED(hr)) |
427 return false; | 411 return false; |
428 | 412 |
429 return true; | 413 return true; |
430 } | 414 } |
431 | 415 |
432 void DataFetcherSharedMemory::DisableSensors(ConsumerType consumer_type) { | 416 void DataFetcherSharedMemory::DisableSensors(ConsumerType consumer_type) { |
433 switch(consumer_type) { | 417 switch (consumer_type) { |
434 case CONSUMER_TYPE_ORIENTATION: | 418 case CONSUMER_TYPE_ORIENTATION: |
435 if (sensor_inclinometer_.get()) { | 419 if (sensor_inclinometer_.get()) { |
436 sensor_inclinometer_->SetEventSink(nullptr); | 420 sensor_inclinometer_->SetEventSink(nullptr); |
437 sensor_inclinometer_.Release(); | 421 sensor_inclinometer_.Release(); |
438 } | 422 } |
439 break; | 423 break; |
440 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: | 424 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: |
441 if (sensor_inclinometer_absolute_.get()) { | 425 if (sensor_inclinometer_absolute_.get()) { |
442 sensor_inclinometer_absolute_->SetEventSink(nullptr); | 426 sensor_inclinometer_absolute_->SetEventSink(nullptr); |
443 sensor_inclinometer_absolute_.Release(); | 427 sensor_inclinometer_absolute_.Release(); |
(...skipping 14 matching lines...) Expand all Loading... |
458 sensor_light_->SetEventSink(nullptr); | 442 sensor_light_->SetEventSink(nullptr); |
459 sensor_light_.Release(); | 443 sensor_light_.Release(); |
460 } | 444 } |
461 break; | 445 break; |
462 default: | 446 default: |
463 NOTREACHED(); | 447 NOTREACHED(); |
464 } | 448 } |
465 } | 449 } |
466 | 450 |
467 void DataFetcherSharedMemory::SetBufferAvailableState( | 451 void DataFetcherSharedMemory::SetBufferAvailableState( |
468 ConsumerType consumer_type, bool enabled) { | 452 ConsumerType consumer_type, |
469 switch(consumer_type) { | 453 bool enabled) { |
| 454 switch (consumer_type) { |
470 case CONSUMER_TYPE_ORIENTATION: | 455 case CONSUMER_TYPE_ORIENTATION: |
471 if (orientation_buffer_) { | 456 if (orientation_buffer_) { |
472 orientation_buffer_->seqlock.WriteBegin(); | 457 orientation_buffer_->seqlock.WriteBegin(); |
473 orientation_buffer_->data.allAvailableSensorsAreActive = enabled; | 458 orientation_buffer_->data.allAvailableSensorsAreActive = enabled; |
474 orientation_buffer_->seqlock.WriteEnd(); | 459 orientation_buffer_->seqlock.WriteEnd(); |
475 } | 460 } |
476 break; | 461 break; |
477 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: | 462 case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: |
478 if (orientation_absolute_buffer_) { | 463 if (orientation_absolute_buffer_) { |
479 orientation_absolute_buffer_->seqlock.WriteBegin(); | 464 orientation_absolute_buffer_->seqlock.WriteBegin(); |
480 orientation_absolute_buffer_->data.allAvailableSensorsAreActive = | 465 orientation_absolute_buffer_->data.allAvailableSensorsAreActive = |
481 enabled; | 466 enabled; |
482 orientation_absolute_buffer_->seqlock.WriteEnd(); | 467 orientation_absolute_buffer_->seqlock.WriteEnd(); |
483 } | 468 } |
484 break; | 469 break; |
485 case CONSUMER_TYPE_MOTION: | 470 case CONSUMER_TYPE_MOTION: |
486 if (motion_buffer_) { | 471 if (motion_buffer_) { |
487 motion_buffer_->seqlock.WriteBegin(); | 472 motion_buffer_->seqlock.WriteBegin(); |
488 motion_buffer_->data.allAvailableSensorsAreActive = enabled; | 473 motion_buffer_->data.allAvailableSensorsAreActive = enabled; |
489 motion_buffer_->seqlock.WriteEnd(); | 474 motion_buffer_->seqlock.WriteEnd(); |
490 } | 475 } |
491 break; | 476 break; |
492 default: | 477 default: |
493 NOTREACHED(); | 478 NOTREACHED(); |
494 } | 479 } |
495 } | 480 } |
496 | 481 |
497 } // namespace content | 482 } // namespace device |
OLD | NEW |