[sensors][win] Add support for AbsoluteOrientation sensor

device/generic_sensor/platform_sensor_reader_win.cc

 // 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 "device/generic_sensor/platform_sensor_reader_win.h"
 
 #include <Sensors.h>
 
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/win/iunknown_impl.h"
+#include "base/win/scoped_propvariant.h"
 #include "device/generic_sensor/generic_sensor_consts.h"
 #include "device/generic_sensor/public/cpp/platform_sensor_configuration.h"
 #include "device/generic_sensor/public/cpp/sensor_reading.h"
 
 namespace device {
 
 // Init params for the PlatformSensorReaderWin.
 struct ReaderInitParams {
   // ISensorDataReport::GetSensorValue is not const, therefore, report
   // cannot be passed as const ref.
   // ISensorDataReport& report - report that contains new sensor data.
   // SensorReading& reading    - out parameter that must be populated.
   // Returns HRESULT           - S_OK on success, otherwise error code.
   using ReaderFunctor = base::Callback<HRESULT(ISensorDataReport& report,
                                                SensorReading& reading)>;
   SENSOR_TYPE_ID sensor_type_id;
   ReaderFunctor reader_func;
   unsigned long min_reporting_interval_ms = 0;
 };
 
 namespace {
 
 // Gets value from  the report for provided key.
 bool GetReadingValueForProperty(REFPROPERTYKEY key,
                                 ISensorDataReport& report,
                                 double* value) {
   DCHECK(value);
-  PROPVARIANT variant_value = {};
-  if (SUCCEEDED(report.GetSensorValue(key, &variant_value))) {
-    if (variant_value.vt == VT_R8)
-      *value = variant_value.dblVal;
-    else if (variant_value.vt == VT_R4)
-      *value = variant_value.fltVal;
+  base::win::ScopedPropVariant variant_value;
+  if (SUCCEEDED(report.GetSensorValue(key, variant_value.Receive()))) {
+    if (variant_value.get().vt == VT_R8)
+      *value = variant_value.get().dblVal;
+    else if (variant_value.get().vt == VT_R4)
+      *value = variant_value.get().fltVal;
     else
       return false;
     return true;
   }
 
   *value = 0;
   return false;
 }
 
 // Ambient light sensor reader initialization parameters.
@@ skipping 100 matching lines @@
         // sign for each axis. Values are converted from Milligaus to
         // Microtesla.
         reading.values[0] = -x * kMicroteslaInMilligauss;
         reading.values[1] = -y * kMicroteslaInMilligauss;
         reading.values[2] = -z * kMicroteslaInMilligauss;
         return S_OK;
       });
   return params;
 }
 
+// AbsoluteOrientation sensor reader initialization parameters.
+std::unique_ptr<ReaderInitParams> CreateAbsoluteOrientationReaderInitParams() {
+  auto params = base::MakeUnique<ReaderInitParams>();
+  params->sensor_type_id = SENSOR_TYPE_AGGREGATED_DEVICE_ORIENTATION;
+  params->reader_func =
+      base::Bind([](ISensorDataReport& report, SensorReading& reading) {
+        base::win::ScopedPropVariant quat_variant;
+        HRESULT hr = report.GetSensorValue(SENSOR_DATA_TYPE_QUATERNION,
+                                           quat_variant.Receive());
+        if (FAILED(hr) || quat_variant.get().vt != (VT_VECTOR | VT_UI1) ||
+            quat_variant.get().caub.cElems < 16) {
+          return E_FAIL;
+        }
+
+        float* quat = reinterpret_cast<float*>(quat_variant.get().caub.pElems);
+
+        // Windows uses coordinate system where Z axis points down from device
+        // screen, therefore, using right hand notation, we have to reverse
+        // sign for each quaternion component.
+        reading.values[0] = -quat[0];  // x*sin(Theta/2)
+        reading.values[1] = -quat[1];  // y*sin(Theta/2)
+        reading.values[2] = -quat[2];  // z*sin(Theta/2)
+        reading.values[3] = quat[3];   // cos(Theta/2)
+        return S_OK;
+      });
+  return params;
+}
+
 // Creates ReaderInitParams params structure. To implement support for new
 // sensor types, new switch case should be added and appropriate fields must
 // be set:
 // sensor_type_id - GUID of the sensor supported by Windows.
 // reader_func    - Functor that is responsible to populate SensorReading from
 //                  ISensorDataReport data.
 std::unique_ptr<ReaderInitParams> CreateReaderInitParamsForSensor(
     mojom::SensorType type) {
   switch (type) {
     case mojom::SensorType::AMBIENT_LIGHT:
       return CreateAmbientLightReaderInitParams();
     case mojom::SensorType::ACCELEROMETER:
       return CreateAccelerometerReaderInitParams();
     case mojom::SensorType::GYROSCOPE:
       return CreateGyroscopeReaderInitParams();
     case mojom::SensorType::MAGNETOMETER:
       return CreateMagnetometerReaderInitParams();
+    case mojom::SensorType::ABSOLUTE_ORIENTATION:
+      return CreateAbsoluteOrientationReaderInitParams();
     default:
       NOTIMPLEMENTED();
       return nullptr;
   }
 }
 
 }  // namespace
 
 // Class that implements ISensorEvents and IUnknown interfaces and used
 // by ISensor interface to dispatch state and data change events.
@@ skipping 104 matching lines @@
   DCHECK(sensor_manager);
 
   auto params = CreateReaderInitParamsForSensor(type);
   if (!params)
     return nullptr;
 
   auto sensor = GetSensorForType(params->sensor_type_id, sensor_manager);
   if (!sensor)
     return nullptr;
 
-  PROPVARIANT variant = {};
-  HRESULT hr =
-      sensor->GetProperty(SENSOR_PROPERTY_MIN_REPORT_INTERVAL, &variant);
-  if (SUCCEEDED(hr) && variant.vt == VT_UI4)
-    params->min_reporting_interval_ms = variant.ulVal;
+  base::win::ScopedPropVariant min_interval;
+  HRESULT hr = sensor->GetProperty(SENSOR_PROPERTY_MIN_REPORT_INTERVAL,
+                                   min_interval.Receive());
+  if (SUCCEEDED(hr) && min_interval.get().vt == VT_UI4)
+    params->min_reporting_interval_ms = min_interval.get().ulVal;
 
   GUID interests[] = {SENSOR_EVENT_STATE_CHANGED, SENSOR_EVENT_DATA_UPDATED};
   hr = sensor->SetEventInterest(interests, arraysize(interests));
   if (FAILED(hr))
     return nullptr;
 
   return base::WrapUnique(
       new PlatformSensorReaderWin(sensor, std::move(params)));
 }
 
@@ skipping 107 matching lines @@
 void PlatformSensorReaderWin::SensorError() {
   if (client_)
     client_->OnSensorError();
 }
 
 unsigned long PlatformSensorReaderWin::GetMinimalReportingIntervalMs() const {
   return init_params_->min_reporting_interval_ms;
 }
 
 }  // namespace device