hal/windows/WindowsSensor.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   3  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "Hal.h"
   6
   7 #include <sensorsapi.h>
   8 #include <sensors.h>
   9 #include <portabledevicetypes.h>
  10
  11 #define MEAN_GRAVITY 9.80665
  12 #define DEFAULT_SENSOR_POLL 100
  13
  14 using namespace mozilla::hal;
  15
  16 namespace mozilla {
  17 namespace hal_impl {
  18
  19 static nsRefPtr<ISensor> sAccelerometer;
  20
  21 class SensorEvent MOZ_FINAL : public ISensorEvents {
  22 public:
  23   SensorEvent() : mCount(0) {
  24   }
  25
  26   // IUnknown interface
  27
  28   STDMETHODIMP_(ULONG) AddRef() {
  29     return InterlockedIncrement(&mCount);
  30   }
  31
  32   STDMETHODIMP_(ULONG) Release() {
  33     ULONG count = InterlockedDecrement(&mCount);
  34     if (!count) {
  35       delete this;
  36       return 0;
  37     }
  38     return count;
  39   }
  40
  41   STDMETHODIMP QueryInterface(REFIID iid, void** ppv) {
  42     if (iid == IID_IUnknown) {
  43       *ppv = static_cast<IUnknown*>(this);
  44     } else if (iid == IID_ISensorEvents) {
  45       *ppv = static_cast<ISensorEvents*>(this);
  46     } else {
  47       return E_NOINTERFACE;
  48     }
  49     AddRef();
  50     return S_OK;
  51   }
  52
  53   // ISensorEvents interface
  54
  55   STDMETHODIMP OnEvent(ISensor *aSensor, REFGUID aId, IPortableDeviceValues *aData) {
  56     return S_OK;
  57   }
  58
  59   STDMETHODIMP OnLeave(REFSENSOR_ID aId) {
  60     return S_OK;
  61   }
  62
  63   STDMETHODIMP OnStateChanged(ISensor *aSensor, SensorState state) {
  64     return S_OK;
  65   }
  66
  67   STDMETHODIMP OnDataUpdated(ISensor *aSensor, ISensorDataReport *aReport) {
  68     PROPVARIANT v;
  69     HRESULT hr;
  70     InfallibleTArray<float> values;
  71
  72     // X-axis acceleration in g's
  73     hr = aReport->GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_X_G, &v);
  74     if (FAILED(hr)) {
  75       return hr;
  76     }
  77     values.AppendElement(float(-v.dblVal * MEAN_GRAVITY));
  78
  79     // Y-axis acceleration in g's
  80     hr = aReport->GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_Y_G, &v);
  81     if (FAILED(hr)) {
  82       return hr;
  83     }
  84     values.AppendElement(float(-v.dblVal * MEAN_GRAVITY));
  85
  86     // Z-axis acceleration in g's
  87     hr = aReport->GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_Z_G, &v);
  88     if (FAILED(hr)) {
  89       return hr;
  90     }
  91     values.AppendElement(float(-v.dblVal * MEAN_GRAVITY));
  92
  93     hal::SensorData sdata(hal::SENSOR_ACCELERATION,
  94                           PR_Now(),
  95                           values,
  96                           hal::SENSOR_ACCURACY_UNKNOWN);
  97     hal::NotifySensorChange(sdata);
  98
  99     return S_OK;
 100   }
 101
 102 private:
 103   ULONG mCount;
 104 };
 105
 106 void
 107 EnableSensorNotifications(SensorType aSensor)
 108 {
 109   if (aSensor != SENSOR_ACCELERATION) {
 110     return;
 111   }
 112
 113   if (sAccelerometer) {
 114     return;
 115   }
 116
 117   nsRefPtr<ISensorManager> manager;
 118   if (FAILED(CoCreateInstance(CLSID_SensorManager, NULL, CLSCTX_INPROC_SERVER,
 119                               IID_ISensorManager, getter_AddRefs(manager)))) {
 120     return;
 121   }
 122
 123   // accelerometer event
 124
 125   nsRefPtr<ISensorCollection> collection;
 126   if (FAILED(manager->GetSensorsByType(SENSOR_TYPE_ACCELEROMETER_3D,
 127                                        getter_AddRefs(collection)))) {
 128     return;
 129   }
 130
 131   ULONG count = 0;
 132   collection->GetCount(&count);
 133   if (!count) {
 134     return;
 135   }
 136
 137   nsRefPtr<ISensor> sensor;
 138   collection->GetAt(0, getter_AddRefs(sensor));
 139   if (!sensor) {
 140     return;
 141   }
 142
 143   // Set report interval to 100ms if possible.
 144   // Default value depends on drivers.
 145   nsRefPtr<IPortableDeviceValues> values;
 146   if (SUCCEEDED(CoCreateInstance(CLSID_PortableDeviceValues, NULL,
 147                                  CLSCTX_INPROC_SERVER,
 148                                  IID_IPortableDeviceValues,
 149                                  getter_AddRefs(values)))) {
 150     if (SUCCEEDED(values->SetUnsignedIntegerValue(
 151                     SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL,
 152                     DEFAULT_SENSOR_POLL))) {
 153       nsRefPtr<IPortableDeviceValues> returns;
 154       sensor->SetProperties(values, getter_AddRefs(returns));
 155     }
 156   }
 157
 158   nsRefPtr<SensorEvent> event = new SensorEvent();
 159   nsRefPtr<ISensorEvents> sensorEvents;
 160   if (FAILED(event->QueryInterface(IID_ISensorEvents,
 161                                    getter_AddRefs(sensorEvents)))) {
 162     return;
 163   }
 164
 165   if (FAILED(sensor->SetEventSink(sensorEvents))) {
 166     return;
 167   }
 168
 169   sAccelerometer = sensor;
 170 }
 171
 172 void
 173 DisableSensorNotifications(SensorType aSensor)
 174 {
 175   if (aSensor == SENSOR_ACCELERATION && sAccelerometer) {
 176     sAccelerometer->SetEventSink(NULL);
 177     sAccelerometer = nullptr;
 178   }
 179 }
 180
 181 } // hal_impl
 182 } // mozilla