src/FUixSensor_SensorEventDeliverer.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.tizenopensource.org/license
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file     FUixSensor_SensorEventDeliverer.cpp
  20  * @brief    This is the implementation file for the %_SensorEventDeliverer class.
  21  *
  22  * This files contains implementation of the %_SensorEventDeliverer class.
  23  */
  24
  25 // Includes
  26 #include <FBaseSysLog.h>
  27
  28 #include <FUixSensorSensorData.h>
  29 #include <FUixSensorAccelerationSensorData.h>
  30 #include <FUixSensorMagneticSensorData.h>
  31 #include <FUixSensorProximitySensorData.h>
  32 #include <FUixSensorTiltSensorData.h>
  33 #include <FUixSensorGyroSensorData.h>
  34 #include <FUixSensorLightSensorData.h>
  35 #include <FUixSensorISensorEventListener.h>
  36
  37 #include "FUixSensor_SensorEventDeliverer.h"
  38 #include "FUixSensor_ISensorCore.h"
  39 #include "FUixSensor_SensorCoreEventTypes.h"
  40 #include "FUixSensor_SensorUtil.h"
  41
  42 namespace Tizen { namespace Uix { namespace Sensor
  43 {
  44 _SensorEventDeliverer::_SensorEventDeliverer(void)
  45         : __eventType(_SensorEventDeliverer::SENSOR_EVENT_TYPE_NONE)
  46         , __pListener(null)
  47         , __sensorType(SENSOR_TYPE_NONE)
  48         , __interval(INVALID_SENSOR_CORE_EVENT_INTERVAL)
  49         , __dataChanged(false)
  50         , __sensorCoreEventHandle(INVALID_SENSOR_CORE_EVENT_HANDLE)
  51         , __state(SENSOR_CORE_EVENT_RECEIVER_STATE_NONE)
  52         , __currentSensorCoreEvent(INVALID_SENSOR_CORE_EVENT)
  53         , __beforeSensorCoreEvent(INVALID_SENSOR_CORE_EVENT)
  54 {
  55
  56 }
  57
  58 _SensorEventDeliverer::~_SensorEventDeliverer(void)
  59 {
  60         if (GetSensorCoreEventReceiverState() != SENSOR_CORE_EVENT_RECEIVER_STATE_NONE)
  61         {
  62                 Stop();
  63         }
  64 }
  65
  66 void
  67 _SensorEventDeliverer::SetDataEventInfo(Tizen::Uix::Sensor::ISensorEventListener& listener, Tizen::Uix::Sensor::SensorType sensorType, long interval, bool dataChanged)
  68 {
  69         __eventType = _SensorEventDeliverer::SENSOR_EVENT_TYPE_DATA;
  70         __pListener = &listener;
  71         __sensorType = sensorType;
  72         __interval = interval;
  73         __dataChanged = dataChanged;
  74 }
  75
  76 void
  77 _SensorEventDeliverer::SetWakeupEventInfo(Tizen::Uix::Sensor::ISensorEventListener& listener, Tizen::Uix::Sensor::SensorType sensorType)
  78 {
  79         __eventType = _SensorEventDeliverer::SENSOR_EVENT_TYPE_WAKE_UP;
  80         __pListener = &listener;
  81         __sensorType = sensorType;
  82 }
  83
  84 bool
  85 _SensorEventDeliverer::IsListenerEquals(ISensorEventListener& listener) const
  86 {
  87         return __pListener == &listener;
  88 }
  89
  90 result
  91 _SensorEventDeliverer::Start(void)
  92 {
  93         return _ISensorCore::AddSensorCoreEventReceiver(*this);
  94 }
  95
  96 result
  97 _SensorEventDeliverer::Stop(void)
  98 {
  99         return _ISensorCore::RemoveSensorCoreEventReceiver(*this);
 100 }
 101
 102 result
 103 _SensorEventDeliverer::ResetInterval(long interval)
 104 {
 105         if (!IsEquals(__interval, interval))
 106         {
 107                 __interval = interval;
 108                 // TODO: Use it
 109 //              return _ISensorCore::ResetSensorCoreEventReceivingInterval(*this);
 110
 111                 // Temporary implementation
 112                 result r = _ISensorCore::RemoveSensorCoreEventReceiver(*this);
 113                 if (IsFailed(r))
 114                 {
 115                         return r;
 116                 }
 117                 return _ISensorCore::AddSensorCoreEventReceiver(*this);
 118         }
 119
 120         return E_SUCCESS;
 121 }
 122
 123 Tizen::Uix::Sensor::SensorData&
 124 _SensorEventDeliverer::GetSensorDataBuffer(void)
 125 {
 126         static SensorData sensorData;
 127         return sensorData;
 128 }
 129
 130 namespace
 131 {
 132 _SensorCoreEventType
 133 ConvertToSensorCoreDataEventTypeFromSensorType(SensorType sensorType)
 134 {
 135         switch (sensorType)
 136         {
 137         case SENSOR_TYPE_ACCELERATION:
 138                 return _SENSOR_CORE_EVENT_TYPE_ACCELERATION_DATA;
 139         case SENSOR_TYPE_MAGNETIC:
 140                 return _SENSOR_CORE_EVENT_TYPE_MAGNETIC_FIELD_DATA;
 141         case SENSOR_TYPE_PROXIMITY:
 142                 return _SENSOR_CORE_EVENT_TYPE_PROXIMITY_DISTANCE_DATA;
 143         case SENSOR_TYPE_TILT:
 144                 return _SENSOR_CORE_EVENT_TYPE_TILT_DATA;
 145         case SENSOR_TYPE_GYRO:
 146                 return _SENSOR_CORE_EVENT_TYPE_ROTATION_RATE_DATA;
 147         case SENSOR_TYPE_LIGHT:
 148                 return _SENSOR_CORE_EVENT_TYPE_LIGHT_LEVEL_DATA;
 149         default:
 150                 SysAssertf(false, "ConvertToSensorCoreEventTypeFromSensorType() > Invalid SensorType [sensorType:%d]", sensorType);
 151                 return _SENSOR_CORE_EVENT_TYPE_NONE;
 152         }
 153 }
 154
 155 _SensorCoreEventType
 156 ConvertToSensorCoreWakeupEventTypeFromSensorType(SensorType sensorType)
 157 {
 158         switch (sensorType)
 159         {
 160         case SENSOR_TYPE_ACCELERATION:
 161                 return _SENSOR_CORE_EVENT_TYPE_ACCELERATION_SENSOR_WAKEUP;
 162         default:
 163                 SysAssertf(false, "ConvertToSensorCoreEventTypeFromSensorType() > Invalid SensorType [sensorType:%d]", sensorType);
 164                 return _SENSOR_CORE_EVENT_TYPE_NONE;
 165         }
 166 }
 167
 168 bool
 169 IsSensorCoreEventChanged(_SensorCoreEventType eventType, _SensorCoreEvent& before, _SensorCoreEvent& after)
 170 {
 171         switch (eventType)
 172         {
 173         case _SENSOR_CORE_EVENT_TYPE_ACCELERATION_DATA:
 174                 {
 175                         if (IsEquals(before.eventKind.accelerationData.x, after.eventKind.accelerationData.x) &&
 176                                 IsEquals(before.eventKind.accelerationData.y, after.eventKind.accelerationData.y) &&
 177                                 IsEquals(before.eventKind.accelerationData.z, after.eventKind.accelerationData.z))
 178                         {
 179                                 return false;
 180                         }
 181                         break;
 182                 }
 183         case _SENSOR_CORE_EVENT_TYPE_MAGNETIC_FIELD_DATA:
 184                 {
 185                         if (IsEquals(before.eventKind.magneticFieldData.x, after.eventKind.magneticFieldData.x) &&
 186                                 IsEquals(before.eventKind.magneticFieldData.y, after.eventKind.magneticFieldData.y) &&
 187                                 IsEquals(before.eventKind.magneticFieldData.z, after.eventKind.magneticFieldData.z))
 188                         {
 189                                 return false;
 190                         }
 191                         break;
 192                 }
 193         case _SENSOR_CORE_EVENT_TYPE_PROXIMITY_DISTANCE_DATA:
 194                 {
 195                         if (IsEquals(before.eventKind.proximityDistanceData.distance, after.eventKind.proximityDistanceData.distance))
 196                         {
 197                                 return false;
 198                         }
 199                         break;
 200                 }
 201         case _SENSOR_CORE_EVENT_TYPE_TILT_DATA:
 202                 {
 203                         if (IsEquals(before.eventKind.tiltData.roll, after.eventKind.tiltData.roll)  &&
 204                                 IsEquals(before.eventKind.tiltData.pitch, after.eventKind.tiltData.pitch) &&
 205                                 IsEquals(before.eventKind.tiltData.azimuth, after.eventKind.tiltData.azimuth))
 206                         {
 207                                 return false;
 208                         }
 209                         break;
 210                 }
 211         case _SENSOR_CORE_EVENT_TYPE_ROTATION_RATE_DATA:
 212                 {
 213                         if (IsEquals(before.eventKind.rotationRateData.x, after.eventKind.rotationRateData.x)  &&
 214                                 IsEquals(before.eventKind.rotationRateData.y, after.eventKind.rotationRateData.y) &&
 215                                 IsEquals(before.eventKind.rotationRateData.z, after.eventKind.rotationRateData.z))
 216                         {
 217                                 return false;
 218                         }
 219                         break;
 220                 }
 221         case _SENSOR_CORE_EVENT_TYPE_LIGHT_LEVEL_DATA:
 222                 {
 223                         if (IsEquals(before.eventKind.lightLevelData.level, after.eventKind.lightLevelData.level))
 224                         {
 225                                 return false;
 226                         }
 227                         break;
 228                 }
 229         default:
 230                 {
 231                         SysAssertf(false, "IsSensorCoreEventChanged() > Invalid _SensorCoreEventType [eventType:%d]", eventType);
 232                         return false;
 233                 }
 234         }
 235
 236         return true;
 237 }
 238 } // Anonymous
 239
 240 _SensorCoreEventType
 241 _SensorEventDeliverer::GetSensorCoreEventType(void) const
 242 {
 243         if (__eventType == _SensorEventDeliverer::SENSOR_EVENT_TYPE_WAKE_UP)
 244         {
 245                 return ConvertToSensorCoreWakeupEventTypeFromSensorType(__sensorType);
 246         }
 247         else
 248         {
 249                 return ConvertToSensorCoreDataEventTypeFromSensorType(__sensorType);
 250         }
 251 }
 252
 253 long
 254 _SensorEventDeliverer::GetSensorCoreDataEventInterval(void) const
 255 {
 256         return __interval;
 257 }
 258
 259 void
 260 _SensorEventDeliverer::SetSensorCoreEventHandle(_SensorCoreEventHandle sensorCoreEventHandle)
 261 {
 262         __sensorCoreEventHandle = sensorCoreEventHandle;
 263 }
 264
 265 _SensorCoreEventHandle
 266 _SensorEventDeliverer::GetSensorCoreEventHandle(void) const
 267 {
 268         return __sensorCoreEventHandle;
 269 }
 270
 271 void
 272 _SensorEventDeliverer::SetSensorCoreEventReceiverState(SensorCoreEventReceiverState state)
 273 {
 274         __state = state;
 275 }
 276
 277 _ISensorCoreEventReceiver::SensorCoreEventReceiverState
 278 _SensorEventDeliverer::GetSensorCoreEventReceiverState(void) const
 279 {
 280         return __state;
 281 }
 282
 283 _SensorCoreEvent&
 284 _SensorEventDeliverer::GetSensorCoreEventBuffer(void)
 285 {
 286         return __currentSensorCoreEvent;
 287 }
 288
 289 void
 290 _SensorEventDeliverer::OnSensorCoreEventReceived(_SensorCoreEvent& event)
 291 {
 292         _SensorCoreEventType eventType = event.eventType;
 293         if (__dataChanged)
 294         {
 295                 if (!IsSensorCoreEventChanged(eventType, __beforeSensorCoreEvent, event))
 296                 {
 297                         __beforeSensorCoreEvent = event;
 298                         return;
 299                 }
 300
 301                 __beforeSensorCoreEvent = event;
 302         }
 303
 304         SensorData& sensorDataBuffer = GetSensorDataBuffer();
 305         sensorDataBuffer.timestamp = event.eventTimestamp;
 306
 307         switch (eventType)
 308         {
 309         case _SENSOR_CORE_EVENT_TYPE_ACCELERATION_DATA:
 310                 {
 311                         static_cast<AccelerationSensorData&>(sensorDataBuffer).x = event.eventKind.accelerationData.x;
 312                         static_cast<AccelerationSensorData&>(sensorDataBuffer).y = event.eventKind.accelerationData.y;
 313                         static_cast<AccelerationSensorData&>(sensorDataBuffer).z = event.eventKind.accelerationData.z;
 314                         break;
 315                 }
 316         case _SENSOR_CORE_EVENT_TYPE_MAGNETIC_FIELD_DATA:
 317                 {
 318                         static_cast<MagneticSensorData&>(sensorDataBuffer).x = event.eventKind.magneticFieldData.x;
 319                         static_cast<MagneticSensorData&>(sensorDataBuffer).y = event.eventKind.magneticFieldData.y;
 320                         static_cast<MagneticSensorData&>(sensorDataBuffer).z = event.eventKind.magneticFieldData.z;
 321                         break;
 322                 }
 323         case _SENSOR_CORE_EVENT_TYPE_PROXIMITY_DISTANCE_DATA:
 324                 {
 325                         static_cast<ProximitySensorData&>(sensorDataBuffer).distance = event.eventKind.proximityDistanceData.distance;
 326                         break;
 327                 }
 328         case _SENSOR_CORE_EVENT_TYPE_TILT_DATA:
 329                 {
 330                         static_cast<TiltSensorData&>(sensorDataBuffer).roll = event.eventKind.tiltData.roll;
 331                         static_cast<TiltSensorData&>(sensorDataBuffer).pitch = event.eventKind.tiltData.pitch;
 332                         static_cast<TiltSensorData&>(sensorDataBuffer).azimuth = event.eventKind.tiltData.azimuth;
 333                         break;
 334                 }
 335         case _SENSOR_CORE_EVENT_TYPE_ROTATION_RATE_DATA:
 336                 {
 337                         static_cast<GyroSensorData&>(sensorDataBuffer).x = event.eventKind.rotationRateData.x;
 338                         static_cast<GyroSensorData&>(sensorDataBuffer).y = event.eventKind.rotationRateData.y;
 339                         static_cast<GyroSensorData&>(sensorDataBuffer).z = event.eventKind.rotationRateData.z;
 340                         break;
 341                 }
 342         case _SENSOR_CORE_EVENT_TYPE_LIGHT_LEVEL_DATA:
 343                 {
 344                         static_cast<LightSensorData&>(sensorDataBuffer).level = event.eventKind.lightLevelData.level;
 345                         break;
 346                 }
 347         default:
 348                 {
 349                         SysAssertf(false, "OnSensorCoreEventReceived() > Invalid _SensorCoreEventType [eventType:%d]", eventType);
 350                         return;
 351                 }
 352         }
 353
 354         __pListener->OnDataReceived(__sensorType, sensorDataBuffer, event.isEventValid ? E_SUCCESS : E_INVALID_ARG);
 355 }
 356 } } }// Tizen::Uix::Sensor