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.1 (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://floralicense.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 <FUixSensorGravitySensorData.h>
  36 #include <FUixSensorUserAccelerationSensorData.h>
  37 #include <FUixSensorDeviceOrientationSensorData.h>
  38
  39 #include <FUixSensorISensorEventListener.h>
  40
  41 #include "FUixSensor_SensorEventDeliverer.h"
  42 #include "FUixSensor_ISensorCore.h"
  43 #include "FUixSensor_SensorCoreEventTypes.h"
  44 #include "FUixSensor_SensorUtil.h"
  45
  46 namespace Tizen { namespace Uix { namespace Sensor
  47 {
  48 _SensorEventDeliverer::_SensorEventDeliverer(void)
  49         : __eventType(_SensorEventDeliverer::SENSOR_EVENT_TYPE_NONE)
  50         , __pListener(null)
  51         , __sensorType(SENSOR_TYPE_NONE)
  52         , __interval(INVALID_SENSOR_CORE_EVENT_INTERVAL)
  53         , __dataChanged(false)
  54         , __sensorCoreEventHandle(INVALID_SENSOR_CORE_EVENT_HANDLE)
  55         , __state(SENSOR_CORE_EVENT_RECEIVER_STATE_NONE)
  56         , __currentSensorCoreEvent(INVALID_SENSOR_CORE_EVENT)
  57         , __beforeSensorCoreEvent(INVALID_SENSOR_CORE_EVENT)
  58 {
  59
  60 }
  61
  62 _SensorEventDeliverer::~_SensorEventDeliverer(void)
  63 {
  64         if (GetSensorCoreEventReceiverState() != SENSOR_CORE_EVENT_RECEIVER_STATE_NONE)
  65         {
  66                 Stop();
  67         }
  68 }
  69
  70 void
  71 _SensorEventDeliverer::SetDataEventInfo(Tizen::Uix::Sensor::ISensorEventListener& listener, Tizen::Uix::Sensor::SensorType sensorType, long interval, bool dataChanged)
  72 {
  73         __eventType = _SensorEventDeliverer::SENSOR_EVENT_TYPE_DATA;
  74         __pListener = &listener;
  75         __sensorType = sensorType;
  76         __interval = interval;
  77         __dataChanged = dataChanged;
  78 }
  79
  80 void
  81 _SensorEventDeliverer::SetWakeupEventInfo(Tizen::Uix::Sensor::ISensorEventListener& listener, Tizen::Uix::Sensor::SensorType sensorType)
  82 {
  83         __eventType = _SensorEventDeliverer::SENSOR_EVENT_TYPE_WAKE_UP;
  84         __pListener = &listener;
  85         __sensorType = sensorType;
  86 }
  87
  88 bool
  89 _SensorEventDeliverer::IsListenerEquals(ISensorEventListener& listener) const
  90 {
  91         return __pListener == &listener;
  92 }
  93
  94 result
  95 _SensorEventDeliverer::Start(void)
  96 {
  97         return _ISensorCore::AddSensorCoreEventReceiver(*this);
  98 }
  99
 100 result
 101 _SensorEventDeliverer::Stop(void)
 102 {
 103         return _ISensorCore::RemoveSensorCoreEventReceiver(*this);
 104 }
 105
 106 result
 107 _SensorEventDeliverer::ResetInterval(long interval)
 108 {
 109         if (!IsEquals(__interval, interval))
 110         {
 111                 __interval = interval;
 112                 // TODO: Use it
 113 //              return _ISensorCore::ResetSensorCoreEventReceivingInterval(*this);
 114
 115                 // Temporary implementation
 116                 result r = _ISensorCore::RemoveSensorCoreEventReceiver(*this);
 117                 if (IsFailed(r))
 118                 {
 119                         return r;
 120                 }
 121                 return _ISensorCore::AddSensorCoreEventReceiver(*this);
 122         }
 123
 124         return E_SUCCESS;
 125 }
 126
 127 Tizen::Uix::Sensor::SensorData&
 128 _SensorEventDeliverer::GetSensorDataBuffer(void)
 129 {
 130         static SensorData sensorData;
 131         return sensorData;
 132 }
 133
 134 namespace
 135 {
 136 _SensorCoreEventType
 137 ConvertToSensorCoreDataEventTypeFromSensorType(SensorType sensorType)
 138 {
 139         switch (sensorType)
 140         {
 141         case SENSOR_TYPE_ACCELERATION:
 142                 return _SENSOR_CORE_EVENT_TYPE_ACCELERATION_DATA;
 143         case SENSOR_TYPE_MAGNETIC:
 144                 return _SENSOR_CORE_EVENT_TYPE_MAGNETIC_FIELD_DATA;
 145         case SENSOR_TYPE_PROXIMITY:
 146                 return _SENSOR_CORE_EVENT_TYPE_PROXIMITY_DISTANCE_DATA;
 147         case SENSOR_TYPE_TILT:
 148                 return _SENSOR_CORE_EVENT_TYPE_TILT_DATA;
 149         case SENSOR_TYPE_GYRO:
 150                 return _SENSOR_CORE_EVENT_TYPE_ROTATION_RATE_DATA;
 151         case SENSOR_TYPE_LIGHT:
 152                 return _SENSOR_CORE_EVENT_TYPE_LIGHT_LEVEL_DATA;
 153         case SENSOR_TYPE_GRAVITY:
 154                         return _SENSOR_CORE_EVENT_TYPE_GRAVITY_DATA;
 155         case SENSOR_TYPE_USER_ACCELERATION:
 156                         return _SENSOR_CORE_EVENT_TYPE_USER_ACCELERATION_DATA;
 157         case SENSOR_TYPE_DEVICE_ORIENTATION:
 158                         return _SENSOR_CORE_EVENT_TYPE_DEVICE_ORIENTATION_DATA;
 159         default:
 160                 SysAssertf(false, "ConvertToSensorCoreEventTypeFromSensorType() > Invalid SensorType [sensorType:%d]", sensorType);
 161                 return _SENSOR_CORE_EVENT_TYPE_NONE;
 162         }
 163 }
 164
 165 _SensorCoreEventType
 166 ConvertToSensorCoreWakeupEventTypeFromSensorType(SensorType sensorType)
 167 {
 168         switch (sensorType)
 169         {
 170         case SENSOR_TYPE_ACCELERATION:
 171                 return _SENSOR_CORE_EVENT_TYPE_ACCELERATION_SENSOR_WAKEUP;
 172         default:
 173                 SysAssertf(false, "ConvertToSensorCoreEventTypeFromSensorType() > Invalid SensorType [sensorType:%d]", sensorType);
 174                 return _SENSOR_CORE_EVENT_TYPE_NONE;
 175         }
 176 }
 177
 178 bool
 179 IsSensorCoreEventChanged(_SensorCoreEventType eventType, _SensorCoreEvent& before, _SensorCoreEvent& after)
 180 {
 181         switch (eventType)
 182         {
 183         case _SENSOR_CORE_EVENT_TYPE_ACCELERATION_DATA:
 184                 {
 185                         if (IsEquals(before.eventKind.accelerationData.x, after.eventKind.accelerationData.x) &&
 186                                 IsEquals(before.eventKind.accelerationData.y, after.eventKind.accelerationData.y) &&
 187                                 IsEquals(before.eventKind.accelerationData.z, after.eventKind.accelerationData.z))
 188                         {
 189                                 return false;
 190                         }
 191                         break;
 192                 }
 193         case _SENSOR_CORE_EVENT_TYPE_MAGNETIC_FIELD_DATA:
 194                 {
 195                         if (IsEquals(before.eventKind.magneticFieldData.x, after.eventKind.magneticFieldData.x) &&
 196                                 IsEquals(before.eventKind.magneticFieldData.y, after.eventKind.magneticFieldData.y) &&
 197                                 IsEquals(before.eventKind.magneticFieldData.z, after.eventKind.magneticFieldData.z))
 198                         {
 199                                 return false;
 200                         }
 201                         break;
 202                 }
 203         case _SENSOR_CORE_EVENT_TYPE_PROXIMITY_DISTANCE_DATA:
 204                 {
 205                         if (IsEquals(before.eventKind.proximityDistanceData.distance, after.eventKind.proximityDistanceData.distance))
 206                         {
 207                                 return false;
 208                         }
 209                         break;
 210                 }
 211         case _SENSOR_CORE_EVENT_TYPE_TILT_DATA:
 212                 {
 213                         if (IsEquals(before.eventKind.tiltData.roll, after.eventKind.tiltData.roll)  &&
 214                                 IsEquals(before.eventKind.tiltData.pitch, after.eventKind.tiltData.pitch) &&
 215                                 IsEquals(before.eventKind.tiltData.azimuth, after.eventKind.tiltData.azimuth))
 216                         {
 217                                 return false;
 218                         }
 219                         break;
 220                 }
 221         case _SENSOR_CORE_EVENT_TYPE_ROTATION_RATE_DATA:
 222                 {
 223                         if (IsEquals(before.eventKind.rotationRateData.x, after.eventKind.rotationRateData.x)  &&
 224                                 IsEquals(before.eventKind.rotationRateData.y, after.eventKind.rotationRateData.y) &&
 225                                 IsEquals(before.eventKind.rotationRateData.z, after.eventKind.rotationRateData.z))
 226                         {
 227                                 return false;
 228                         }
 229                         break;
 230                 }
 231         case _SENSOR_CORE_EVENT_TYPE_LIGHT_LEVEL_DATA:
 232                 {
 233                         if (IsEquals(before.eventKind.lightLevelData.level, after.eventKind.lightLevelData.level))
 234                         {
 235                                 return false;
 236                         }
 237                         break;
 238                 }
 239         case _SENSOR_CORE_EVENT_TYPE_GRAVITY_DATA:
 240                 {
 241                         if (IsEquals(before.eventKind.gravityData.x, after.eventKind.gravityData.x) &&
 242                                 IsEquals(before.eventKind.gravityData.y, after.eventKind.gravityData.y) &&
 243                                 IsEquals(before.eventKind.gravityData.z, after.eventKind.gravityData.z))
 244                         {
 245                                 return false;
 246                         }
 247                         break;
 248                 }
 249         case _SENSOR_CORE_EVENT_TYPE_USER_ACCELERATION_DATA:
 250                 {
 251                         if (IsEquals(before.eventKind.userAccelerationData.x, after.eventKind.userAccelerationData.x) &&
 252                                 IsEquals(before.eventKind.userAccelerationData.y, after.eventKind.userAccelerationData.y) &&
 253                                 IsEquals(before.eventKind.userAccelerationData.z, after.eventKind.userAccelerationData.z))
 254                         {
 255                                 return false;
 256                         }
 257                         break;
 258                 }
 259         case _SENSOR_CORE_EVENT_TYPE_DEVICE_ORIENTATION_DATA:
 260                 {
 261                         if (IsEquals(before.eventKind.deviceOrientationData.yaw, after.eventKind.deviceOrientationData.yaw) &&
 262                                 IsEquals(before.eventKind.deviceOrientationData.roll, after.eventKind.deviceOrientationData.roll) &&
 263                                 IsEquals(before.eventKind.deviceOrientationData.pitch, after.eventKind.deviceOrientationData.pitch))
 264                         {
 265                                 return false;
 266                         }
 267                         break;
 268                 }
 269         default:
 270                 {
 271                         SysAssertf(false, "IsSensorCoreEventChanged() > Invalid _SensorCoreEventType [eventType:%d]", eventType);
 272                         return false;
 273                 }
 274         }
 275
 276         return true;
 277 }
 278 } // Anonymous
 279
 280 _SensorCoreEventType
 281 _SensorEventDeliverer::GetSensorCoreEventType(void) const
 282 {
 283         if (__eventType == _SensorEventDeliverer::SENSOR_EVENT_TYPE_WAKE_UP)
 284         {
 285                 return ConvertToSensorCoreWakeupEventTypeFromSensorType(__sensorType);
 286         }
 287         else
 288         {
 289                 return ConvertToSensorCoreDataEventTypeFromSensorType(__sensorType);
 290         }
 291 }
 292
 293 long
 294 _SensorEventDeliverer::GetSensorCoreDataEventInterval(void) const
 295 {
 296         return __interval;
 297 }
 298
 299 void
 300 _SensorEventDeliverer::SetSensorCoreEventHandle(_SensorCoreEventHandle sensorCoreEventHandle)
 301 {
 302         __sensorCoreEventHandle = sensorCoreEventHandle;
 303 }
 304
 305 _SensorCoreEventHandle
 306 _SensorEventDeliverer::GetSensorCoreEventHandle(void) const
 307 {
 308         return __sensorCoreEventHandle;
 309 }
 310
 311 void
 312 _SensorEventDeliverer::SetSensorCoreEventReceiverState(SensorCoreEventReceiverState state)
 313 {
 314         __state = state;
 315 }
 316
 317 _ISensorCoreEventReceiver::SensorCoreEventReceiverState
 318 _SensorEventDeliverer::GetSensorCoreEventReceiverState(void) const
 319 {
 320         return __state;
 321 }
 322
 323 _SensorCoreEvent&
 324 _SensorEventDeliverer::GetSensorCoreEventBuffer(void)
 325 {
 326         return __currentSensorCoreEvent;
 327 }
 328
 329 void
 330 _SensorEventDeliverer::OnSensorCoreEventReceived(_SensorCoreEvent& event)
 331 {
 332         _SensorCoreEventType eventType = event.eventType;
 333         if (__dataChanged)
 334         {
 335                 if (!IsSensorCoreEventChanged(eventType, __beforeSensorCoreEvent, event))
 336                 {
 337                         __beforeSensorCoreEvent = event;
 338                         return;
 339                 }
 340
 341                 __beforeSensorCoreEvent = event;
 342         }
 343
 344         SensorData& sensorDataBuffer = GetSensorDataBuffer();
 345         sensorDataBuffer.timestamp = event.eventTimestamp;
 346
 347         switch (eventType)
 348         {
 349         case _SENSOR_CORE_EVENT_TYPE_ACCELERATION_DATA:
 350                 {
 351                         static_cast<AccelerationSensorData&>(sensorDataBuffer).x = event.eventKind.accelerationData.x;
 352                         static_cast<AccelerationSensorData&>(sensorDataBuffer).y = event.eventKind.accelerationData.y;
 353                         static_cast<AccelerationSensorData&>(sensorDataBuffer).z = event.eventKind.accelerationData.z;
 354                         break;
 355                 }
 356         case _SENSOR_CORE_EVENT_TYPE_MAGNETIC_FIELD_DATA:
 357                 {
 358                         static_cast<MagneticSensorData&>(sensorDataBuffer).x = event.eventKind.magneticFieldData.x;
 359                         static_cast<MagneticSensorData&>(sensorDataBuffer).y = event.eventKind.magneticFieldData.y;
 360                         static_cast<MagneticSensorData&>(sensorDataBuffer).z = event.eventKind.magneticFieldData.z;
 361                         break;
 362                 }
 363         case _SENSOR_CORE_EVENT_TYPE_PROXIMITY_DISTANCE_DATA:
 364                 {
 365                         static_cast<ProximitySensorData&>(sensorDataBuffer).distance = event.eventKind.proximityDistanceData.distance;
 366                         break;
 367                 }
 368         case _SENSOR_CORE_EVENT_TYPE_TILT_DATA:
 369                 {
 370                         static_cast<TiltSensorData&>(sensorDataBuffer).roll = event.eventKind.tiltData.roll;
 371                         static_cast<TiltSensorData&>(sensorDataBuffer).pitch = event.eventKind.tiltData.pitch;
 372                         static_cast<TiltSensorData&>(sensorDataBuffer).azimuth = event.eventKind.tiltData.azimuth;
 373                         break;
 374                 }
 375         case _SENSOR_CORE_EVENT_TYPE_ROTATION_RATE_DATA:
 376                 {
 377                         static_cast<GyroSensorData&>(sensorDataBuffer).x = event.eventKind.rotationRateData.x;
 378                         static_cast<GyroSensorData&>(sensorDataBuffer).y = event.eventKind.rotationRateData.y;
 379                         static_cast<GyroSensorData&>(sensorDataBuffer).z = event.eventKind.rotationRateData.z;
 380                         break;
 381                 }
 382         case _SENSOR_CORE_EVENT_TYPE_LIGHT_LEVEL_DATA:
 383                 {
 384                         static_cast<LightSensorData&>(sensorDataBuffer).level = event.eventKind.lightLevelData.level;
 385                         break;
 386                 }
 387         case _SENSOR_CORE_EVENT_TYPE_GRAVITY_DATA:
 388                 {
 389                         static_cast<GravitySensorData&>(sensorDataBuffer).x = event.eventKind.gravityData.x;
 390                         static_cast<GravitySensorData&>(sensorDataBuffer).y = event.eventKind.gravityData.y;
 391                         static_cast<GravitySensorData&>(sensorDataBuffer).z = event.eventKind.gravityData.z;
 392                         break;
 393                 }
 394         case _SENSOR_CORE_EVENT_TYPE_USER_ACCELERATION_DATA:
 395                 {
 396                         static_cast<UserAccelerationSensorData&>(sensorDataBuffer).x = event.eventKind.userAccelerationData.x;
 397                         static_cast<UserAccelerationSensorData&>(sensorDataBuffer).y = event.eventKind.userAccelerationData.y;
 398                         static_cast<UserAccelerationSensorData&>(sensorDataBuffer).z = event.eventKind.userAccelerationData.z;
 399                         break;
 400                 }
 401         case _SENSOR_CORE_EVENT_TYPE_DEVICE_ORIENTATION_DATA:
 402                 {
 403                         static_cast<DeviceOrientationSensorData&>(sensorDataBuffer).yaw = event.eventKind.deviceOrientationData.yaw;
 404                         static_cast<DeviceOrientationSensorData&>(sensorDataBuffer).roll = event.eventKind.deviceOrientationData.roll;
 405                         static_cast<DeviceOrientationSensorData&>(sensorDataBuffer).pitch = event.eventKind.deviceOrientationData.pitch;
 406                         break;
 407                 }
 408         default:
 409                 {
 410                         SysAssertf(false, "OnSensorCoreEventReceived() > Invalid _SensorCoreEventType [eventType:%d]", eventType);
 411                         return;
 412                 }
 413         }
 414
 415         __pListener->OnDataReceived(__sensorType, sensorDataBuffer, event.isEventValid ? E_SUCCESS : E_INVALID_ARG);
 416 }
 417 } } }// Tizen::Uix::Sensor